model.fit(X_train, y_train, epochs=200, verbose=False)
# Results - Accuracy
scores = model.evaluate(X_train, y_train, verbose=False)
print("Training Accuracy: %.2f%%\n" % (scores[1] * 100))
scores = model.evaluate(X_test, y_test, verbose=False)
print("Testing Accuracy: %.2f%%\n" % (scores[1] * 100))
y_test_pred = model.predict_classes(X_test)
c_matrix = confusion_matrix(y_test, y_test_pred)
ax = sns.heatmap(c_matrix,
annot=True,
xticklabels=['No Diabetes', 'Diabetes'],
yticklabels=['No Diabetes', 'Diabetes'],
cbar=False,
cmap='Blues')
ax.set_xlabel('Prediction')
ax.set_ylabel('Actual')
plt.show()
plt.clf()
# roc curve
y_test_pred_probs = model.predict(X_test)
FPR, TPR, _ = roc_curve(y_test, y_test_pred_probs)
plt.plot(FPR, TPR)
plt.plot([0, 1], [0, 1], '--', color='black') # 대각선
plt.title('ROC Curve')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.show()
plt.clf()
def train_next_model(df):
Y = df[['short-term_memorability', 'long-term_memorability']].values
X = df[['inception', 'short_capt_pred', 'long_capt_pred']].values
# X = df[['inception']].values
print("X shape: ", X.shape)
# X.shape = (6000,5191)
# print("new X shape: ", X.shape)
print("inception: ", X[0, 0])
X_train, X_test, Y_train, Y_test = train_test_split(X,
Y,
test_size=0.2,
random_state=1)
nb_iterations = 8
## divided by 10 all regularizers values
## TODO: change activations params
model = Sequential()
## TODO: add inception feature, change input_shape ?
# model.add(Flatten(input_shape=(5191)))
model.add(
layers.Dense(12,
activation='relu',
kernel_regularizer=regularizers.l2(0.0001),
input_dim=3))
model.add(layers.Dropout(0.6))
model.add(
layers.Dense(12,
activation='relu',
kernel_regularizer=regularizers.l2(0.0001)))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(2, activation='sigmoid'))
# compile the model, changed from rmsprop to adagrad
#Todo: try to change loss & metrics options (and some others ?)
model.compile(optimizer='adagrad', loss='mse', metrics=['accuracy'])
history = model.fit(X_train,
Y_train,
epochs=nb_iterations,
validation_data=(X_test, Y_test))
# visualizing the model
loss = history.history['loss']
val_loss = history.history['val_loss']
##len(loss) == nb_iteration ?
epochs = range(1, len(loss) + 1)
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
plt.figure()
acc = history.history['acc']
val_acc = history.history['val_acc']
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Acc')
plt.legend()
plt.show()
predictions = model.predict(X_test)
print('Short term Spearman\'s correlation coefficient is: %.3f' %
getSpearmanCorScore(predictions[:, 0], Y_test[:, 0]))
print('Long term Spearman\'s correlation coefficient is: %.3f' %
getSpearmanCorScore(predictions[:, 1], Y_test[:, 1]))
model = Sequential()
model.add(LSTM(50, input_shape=(train_X.shape[1], train_X.shape[2])))
model.add(Dense(1))
model.compile(loss='mae', optimizer='adam')
history = model.fit(train_X,
train_y,
epochs=10,
batch_size=72,
validation_data=(test_X, test_y),
verbose=2)
'''
对数据绘图
'''
plt.plot(history.history['loss'], label='train')
plt.plot(history.history['val_loss'], label='test')
plt.legend()
plt.show()
# make the prediction,为了在原始数据的维度上计算损失，需要将数据转化为原来的范围再计算损失
yHat = model.predict(test_X)
inv_yHat = concatenate((yHat, test_x[:, 1:]), axis=1) # 数组拼接
inv_yHat = inv_yHat[:, 0]
test_y = test_y.reshape((len(test_y), 1))
inv_y = concatenate((test_y, test_x[:, 1:]), axis=1)
inv_y = inv_y[:, 0]
rmse = sqrt(mean_squared_error(inv_yHat, inv_y))
print('Test RMSE: %.3f' % rmse)
import os
if not os.path.exists("SavedModels/classifier"):
os.makedirs("SavedModels/classifier")
classifier.save("SavedModels/classifier/model.h5")
#############################################
# Part 3 - Making new prediction
#############################################
from keras.models import load_model
classifier = load_model("SavedModels/classifier/model.h5")
import numpy as np
from keras.preprocessing import image
# load image
test_image = image.load_img('dataset/single_prediction/cat_or_dog_2.jpg',
target_size=(64, 64))
# convert into array
# dimenstion = 64, 64, 3
test_image = image.img_to_array(test_image)
# add batch size as 4th dimension
test_image = np.expand_dims(test_image, axis=0)
# predict
result = classifier.predict(test_image)
# get class attributes
training_set.class_indices
if result[0][0] == 1:
prediction = 'dog'
else:
prediction = 'cat'
print("Evaluation result on Test Data : Loss = {}, accuracy = {}".format(
test_loss, test_acc))
# Task-1 : Plotting the graph for accuracy & loss values respectively of both train and test data.
print(history.history.keys())
# For accuracy values
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
# For loss values
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
# Task-2 : Printing an image and then predicting the digit of the image from the built model.
plt.imshow(test_data[3].reshape(28, 28), cmap='Greys')
plt.title("Digit from the test data")
plt.show()
pred = model.predict(test_data[3].reshape(1, 784))
print("Predicted digit:", pred.argmax())
def models():
data = request.get_json()
if data['model'] == 'svm':
training = pd.read_csv('training.csv')
testing = pd.read_csv('testing.csv')
x_train = training.drop(columns=['target'])
y_train = training['target']
x_test = testing.drop(columns=['target'])
y_test_actual = testing['target']
classifier = SVC(kernel=data['kernel'])
classifier.fit(x_train, y_train)
y_test_obtained = classifier.predict(x_test)
testing['obtained'] = y_test_obtained
testing.to_csv('result.csv', index=False)
plot_confusion_matrix(y_test_actual, y_test_obtained)
plt.savefig('figure.png')
if data['model'] == 'knn':
training = pd.read_csv('training.csv')
testing = pd.read_csv('testing.csv')
x_train = training.drop(columns=['target'])
y_train = training['target']
x_test = testing.drop(columns=['target'])
y_test_actual = testing['target']
classifier = KNeighborsClassifier(n_neighbors=data['k'])
classifier.fit(x_train, y_train)
y_test_obtained = classifier.predict(x_test)
testing['obtained'] = y_test_obtained
testing.to_csv('result.csv', index=False)
plot_confusion_matrix(y_test_actual, y_test_obtained)
plt.savefig('figure.png')
if data['model'] == 'logistic_regression':
training = pd.read_csv('training.csv')
testing = pd.read_csv('testing.csv')
x_train = training.drop(columns=['target'])
y_train = training['target']
x_test = testing.drop(columns=['target'])
y_test_actual = testing['target']
classifier = LogisticRegression(random_state=0,
solver="liblinear",
penalty=data['penalty'])
classifier.fit(x_train, y_train)
y_test_obtained = classifier.predict(x_test)
testing['obtained'] = y_test_obtained
testing.to_csv('result.csv', index=False)
plot_confusion_matrix(y_test_actual, y_test_obtained)
plt.savefig('figure.png')
if data['model'] == 'linear_regression':
training = pd.read_csv('training.csv')
testing = pd.read_csv('testing.csv')
x_train = training.drop(columns=['target'])
y_train = training['target']
x_test = testing.drop(columns=['target'])
y_test_actual = testing['target']
classifier = LinearRegression()
classifier.fit(x_train, y_train)
y_test_obtained = classifier.predict(x_test)
testing['obtained'] = y_test_obtained
testing.to_csv('result.csv', index=False)
plt.scatter(x_train, y_train, color='blue')
plt.scatter(x_test, y_test_actual, color='green')
plt.plot(x_test, y_test_obtained, color='red')
plt.title(
"MSE: " +
str(metrics.mean_squared_error(y_test_actual, y_test_obtained)))
plt.legend(['Fitted Line', 'Training Data', 'Actual Testing Data'])
plt.savefig('figure.png')
if data['model'] == 'nn':
training = pd.read_csv('training.csv')
testing = pd.read_csv('testing.csv')
x_train = training.drop(columns=['target'])
y_train = training['target']
x_test = testing.drop(columns=['target'])
y_test_actual = testing['target']
model = Sequential()
model.add(
Dense(data['layers_dims'][0],
activation=data['layers_activation'][0],
input_shape=(x_train.shape[1], )))
for i in range(1, len(data['layers_dims'])):
model.add(
Dense(data['layers_dims'][i],
activation=data['layers_activation'][i]))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mean_squared_error')
model.fit(x_train, y_train, validation_split=0.2, epochs=30)
y_test_obtained = model.predict(x_test)
testing['obtained'] = y_test_obtained
testing.to_csv('result.csv', index=False)
return jsonify([]), 200
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
history = model.fit(train_data,
train_labels_one_hot,
batch_size=256,
epochs=20,
verbose=1,
validation_data=(test_data, test_labels_one_hot))
[test_loss, test_acc] = model.evaluate(test_data, test_labels_one_hot)
print("Evaluation result on Test Data : Loss = {}, accuracy = {}".format(
test_loss, test_acc))
#graph
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('accuracy')
plt.legend(['train', 'validation'], loc='upper left')
plt.show()
n = 100
plt.imshow(test_images[100, :, :])
single_test = test_images[100, :, :]
single_test = single_test.reshape(1, dimData)
predicted = model.predict(single_test)
print(predicted)
plt.imshow(predicted)
Y_train,
epochs=400,
callbacks=earlyStopping,
validation_data=(X_val, Y_val))
#history = model.fit(X_train, Y_train, batch_size=50, epochs=400, validation_data=(X_val, Y_val)) #without early stopping
#print(history.history.keys())
plt.figure(1)
plt.plot(history.history['loss'], label="Training Loss")
plt.plot(history.history['val_loss'], label="Validation Loss")
plt.legend()
plt.xlabel("Epochs")
plt.ylabel("Loss")
plt.show()
y_predicted = model.predict(x_test)
#print(y_predicted.shape)
for i in range(test_instances):
index = y_predicted[i].argmax()
y_predicted[i] = [0, 0]
y_predicted[i, index] = 1
accuracy = accuracy_score(y_test_matrix, y_predicted)
print("accuracy = ", accuracy)
print(
'Balanced accuracy: ',
balanced_accuracy_score(y_test_matrix.argmax(axis=1),
y_predicted.argmax(axis=1)))
print('f measure = ',
f1_score(y_test_matrix.argmax(axis=1), y_predicted.argmax(axis=1)))
conf_matrix = confusion_matrix(y_test_matrix.argmax(axis=1),
class DNN(Model):
"""
This class is parent class for all Deep neural network models. Any class
inheriting this class should implement `make_default_model` method which
creates a model with a set of hyper parameters.
"""
def __init__(self, input_shape, num_classes, **params):
"""
Constructor to initialize the deep neural network model. Takes the input
shape and number of classes and other parameters required for the
abstract class `Model` as parameters.
Args:
input_shape (tuple): shape of the input
num_classes (int): number of different classes ( labels ) in the data.
**params: Additional parameters required by the underlying abstract
class `Model`.
"""
super(DNN, self).__init__(**params)
self.input_shape = input_shape
self.model = Sequential()
self.make_default_model()
self.model.add(Dense(num_classes, activation='softmax'))
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print(self.model.summary(), file=sys.stderr)
self.save_path = self.save_path or self.name + '_best_model.h5'
def load_model(self, to_load):
"""
Load the model weights from the given path.
Args:
to_load (str): path to the saved model file in h5 format.
"""
try:
self.model.load_weights(to_load)
except:
sys.stderr.write("Invalid saved file provided")
sys.exit(-1)
def save_model(self):
"""
Save the model weights to `save_path` provided while creating the model.
"""
self.model.save_weights(self.save_path)
def train(self, x_train, y_train, x_val=None, y_val=None, n_epochs=50):
"""
Train the model on the given training data.
Args:
x_train (numpy.ndarray): samples of training data.
y_train (numpy.ndarray): labels for training data.
x_val (numpy.ndarray): Optional, samples in the validation data.
y_val (numpy.ndarray): Optional, labels of the validation data.
n_epochs (int): Number of epochs to be trained.
"""
best_acc = 0
if x_val is None or y_val is None:
x_val, y_val = x_train, y_train
for i in range(n_epochs):
# Shuffle the data for each epoch in unison inspired
# from https://stackoverflow.com/a/4602224
p = np.random.permutation(len(x_train))
x_train = x_train[p]
y_train = y_train[p]
self.model.fit(x_train, y_train, batch_size=32, epochs=1)
loss, acc = self.model.evaluate(x_val, y_val)
if acc > best_acc:
best_acc = acc
self.trained = True
def predict_classes(self, x, batch_size=32, verbose=1) -> Tuple:
return self.model.predict_classes(x, batch_size, verbose)
def predict_one(self, sample):
if not self.trained:
sys.stderr.write(
"Model should be trained or loaded before doing predict\n")
sys.exit(-1)
#print out array, see the thresholds. should normalize it (turn it to probabilities) and set our own thresholds (can adjust).
#if neutral is a certain threshold, make it neutral? or if the others are low, then neutral?
print(self.model.predict(np.array([sample])), file=sys.stderr)
predicted_array = self.model.predict(np.array([sample]))
#sys.stdout.write('line 2 to stdout ')
#sys.stdout.write("Hello")
return np.argmax(predicted_array)
if (np.amax(predicted_array) > .98):
return np.argmax(predicted_array)
return 0
def make_default_model(self) -> None:
"""
Make the model with default hyper parameters
"""
# This has to be implemented by child classes. The reason is that the
# hyper parameters depends on the model.
raise NotImplementedError()
LSTM_model.add(Dense(12, activation='sigmoid'))
LSTM_model.compile(loss="binary_crossentropy",
optimizer='adam',
metrics=['accuracy'])
# Training and validation of model is shown along with loss and accuracy per epoch
history = LSTM_model.fit(x_train,
y_train,
epochs=18,
batch_size=64,
validation_split=0.15,
callbacks=[
EarlyStopping(monitor='val_loss',
patience=3,
min_delta=0.0001)
])
# Accuracy of model is calculated and printed
accuracy = LSTM_model.evaluate(x_test, y_test)
print('Accuracy: ', accuracy)
# Test data read in
testData = pd.read_json('nlp_test.json')
testData = testData.transpose()
# Test data cleaned and model used for prediction
testData['body'] = testData['body'].apply(clean)
test = tokenizer.texts_to_sequences(testData['body'].values)
test = pad_sequences(x, maxlen=100)
predictions = LSTM_model.predict(test)
print(scaled.shape)
sequenceLength = 20
n_features = len(data[0])
input = numpy.zeros(
(len(scaled) - sequenceLength, sequenceLength, len(scaled[0])))
output = numpy.zeros((len(scaled) - sequenceLength, len(scaled[0])))
for i in range(0, len(scaled) - sequenceLength):
for j in range(sequenceLength):
input[i, j] = scaled[i + j]
output[i] = scaled[i + sequenceLength]
print(input.shape)
print(output.shape)
model = Sequential()
model.add(
LSTM(n_features,
input_shape=(input.shape[1], input.shape[2]),
return_sequences=True))
model.add(Dropout(0.1))
model.add(Dense(n_features))
#model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
fitted = model.fit(input, output, epochs=400, batch_size=20)
print(output[70])
print(scaler.inverse_transform([model.predict(input)[70]]))
input_data = np.array(inputs, dtype="float")
results = np.array(results)
(trainX, testX, trainY, testY) = train_test_split(input_data, results, test_size=0.25, random_state=42)
window = input_data.shape[1]
model = Sequential()
model.add(Dense(365*24, input_shape=(window,), kernel_initializer='normal', activation="relu"))
model.add(Dense(365, kernel_initializer='normal', activation="relu"))
model.add(Dense(12*4, kernel_initializer='normal', activation="relu"))
model.add(Dense(12, kernel_initializer='normal', activation="relu"))
model.add(Dense(1, kernel_initializer='normal'))
print("[INFO] training network...")
opt = SGD(lr=learning_rate)
model.compile(loss="mean_squared_error", optimizer='adam',
metrics=["mse", "mae", "mape", "cosine"])
# train the neural network
H = model.fit(trainX, trainY, validation_data=(testX, testY),
epochs=epochs, batch_size=32)
# save the model and label binarizer to disk
print("[INFO] serializing network...")
model.save(filename)
# evaluate the network
print("[INFO] evaluating network...")
predictions = model.predict(testX, batch_size=32)
print("Mean squared log error:", mean_squared_log_error(testY, predictions[..., 0]))
class NeuralPlayer(object):
def __init__(self, name, start_balance):
self.money = start_balance
self.hands = []
self.bets = []
self.name = name
self.lose = 0
self.features = []
self.rewards = []
self.model = Sequential()
self.model.add(Dense(32, input_shape=(4, ), activation='relu'))
self.model.add(Dense(64, activation='relu'))
self.model.add(Dense(32, activation='relu'))
self.model.add(Dense(1, activation='sigmoid'))
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
self.model.load_weights('model/%s.h5' % self.name)
self.recognizer_model = load_model(HAND_RECOGNIZER_MODEL_DIR)
print(
"%s: Hi, im %s, a neural network based player and im ready to play"
% (name, name))
def make_bet(self, cards, min_pot, monies, enemy_hands):
t = np.array([cards])
hand = self.recognizer_model.predict(t)
self.hands.append(np.argmax(hand))
m = np.append(monies, enemy_hands)
features = np.append(np.argmax(hand), m)
self.features.append(features)
ff = np.array([features])
prediction = self.model.predict(ff)[0][0] * 100
bet = min(int(prediction), self.money)
if min_pot <= bet < self.money:
bet = bet
elif bet <= min_pot < self.money:
bet = min_pot
elif bet <= min_pot and self.money < min_pot:
bet = self.money
elif bet >= min_pot and bet > self.money:
bet = self.money
else:
bet = bet
self.bets.append(bet)
self.money -= bet
print("%s: My bet is %s" % (self.name, bet))
return bet
def update(self, reward):
self.money += reward
print("%s: My balance is %s" % (self.name, self.money))
self.rewards.append(np.array([0 if reward == 0 else reward / 200.0]))
# res = self.model.fit(np.array(self.features), np.array(self.rewards), batch_size=32, epochs=10)
x = np.array([self.features[-1]])
y = np.array([self.rewards[-1]])
self.model.train_on_batch(x, y)
self.model.save_weights('model/%s.h5' % self.name)
if self.money == 0:
self.lose += 1
return False
else:
return True
from keras.layers import Dense, Embedding, Input, GlobalAveragePooling1D
from keras import Sequential, Model
import numpy as np
embed = (np.arange(0, 20) / 20.0).reshape(10, 2)
model = Sequential()
model.add(
Embedding(input_dim=10,
output_dim=2,
input_length=3,
weights=[embed],
trainable=False))
model.add(GlobalAveragePooling1D())
model.add(Dense(1, activation='sigmoid'))
X = model.predict(np.array([1, 2, 3]).reshape(1, 3))
print(X)
show_shapes=True,
show_layer_names=True)
# fit network
history = model.fit(train_X,
train_y,
epochs=epochs,
batch_size=batch_size,
callbacks=[learning_rate_reduction],
verbose=verbose,
validation_data=(test_X, test_y),
shuffle=False)
#################### Test with the model ####################
# make a prediction
yhat = model.predict(test_X)
# inverse scaler
yhat = yhat * scaler
y_true = test_y * scaler
yhat = process_Y(yhat)
y_true = process_Y(y_true)
Acc_test = (yhat == y_true).astype(int).sum().sum() / yhat.size
# make a prediction
yhat1 = model.predict(train_X)
# inverse scaler
yhat1 = yhat1 * scaler
y_true1 = train_y * scaler
# %% Load model
model = Sequential()
model.add(Dense(7, input_dim=6, activation='relu'))
model.add(Dense(14, activation='relu'))
model.add(Dense(28, activation='relu'))
model.add(Dense(56, activation='relu'))
model.add(Dense(112, activation='relu'))
model.add(Dense(128, activation='softmax'))
model.load_weights('models/NN_train-7-middle-item-as-label.h5')
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# %% Predicting
predictions = model.predict(queryData)
# sum_of_exps = np.sum
replacements = []
for i, prediction in enumerate(predictions):
index = np.where(predictions[i] == np.max(predictions[i]))[0]
# print(index[0])
replacements.append(index[0])
# for i, prediction in enumerate(replacements):
# print(prediction, ' ', np.where(label[i] == 1)[0][0])
# %%
queries = []
for i in range(len(queryData)):
queries.append(
class NeuralNetwork(object):
def __init__(self, input_nodes, hidden_nodes, output_nodes, lr=None):
self.input_nodes = input_nodes
self.hidden_nodes = hidden_nodes
self.output_nodes = output_nodes
self.lr = lr
self.scales_x = []
self.scales_y = []
input_kernel_range = np.sqrt(6) / (np.sqrt(input_nodes) + np.sqrt(hidden_nodes))
input_kernel_initializer = RandomUniform(minval=-input_kernel_range, maxval=input_kernel_range)
input_layer = Dense(input_nodes,
kernel_initializer=input_kernel_initializer,
name='input')
hidden_kernel_range = np.sqrt(6) / (np.sqrt(hidden_nodes) + np.sqrt(output_nodes))
hidden_kernel_initializer = RandomUniform(minval=-hidden_kernel_range, maxval=hidden_kernel_range)
hidden_layer = Dense(hidden_nodes,
kernel_initializer=hidden_kernel_initializer,
name='hidden')
output_layer = Dense(output_nodes,
name='output')
self.model = Sequential()
self.model.add(input_layer)
self.model.add(hidden_layer)
self.model.add(output_layer)
def train(self, x_train, y_train):
self.set_normalize_scales(x_train, y_train)
x_train = self.normalize(x_train, self.scales_x)
y_train = self.normalize(y_train, self.scales_y)
optimizer = SGD(lr=self.lr)
self.model.compile(loss='mse', optimizer=optimizer)
self.model.fit(x_train, y_train, batch_size=20, epochs=500)
def evaluate(self, x_test, y_test):
x_test = self.normalize(x_test, self.scales_x)
y_test = self.normalize(y_test, self.scales_y)
return self.model.evaluate(x_test, y_test)
def predict(self, x):
x = self.normalize(x, self.scales_x)
y = self.model.predict(x)
return self.unnormalize(y, self.scales_y)
def set_normalize_scales(self, x, y):
for i in range(x.shape[1]):
mean, std = x[:, i].mean(), x[:, i].std()
self.scales_x.append([mean, std])
for i in range(y.shape[1]):
mean, std = y[:, i].mean(), y[:, i].std()
self.scales_y.append([mean, std])
@staticmethod
def normalize(data, scales):
for i in range(0, len(scales)):
mean, std = scales[i]
data[:, i] = (data[:, i] - mean) / std
return data
@staticmethod
def unnormalize(data, scales):
for i in range(0, len(scales)):
mean, std = scales[i]
data[:, i] = data[:, i] * std + mean
return data
class Model:
def __init__(self):
# The model
self.model = Sequential()
self.model.add(Dense(16, input_shape=[4,], activation='relu'))
self.model.add(Dense(16, activation='relu'))
self.model.add(Dense(2, activation='linear'))
self.model.compile(optimizer=Adam(0.001),
loss='mse')
# Load the model if available
try:
self.model.load_weights('pole.h5')
except:
pass
# The memory
self.mem_size = 10000
self.batch_size = 32
self.index = 0
self.states = np.zeros([self.mem_size, 4])
self.states_ = np.zeros([self.mem_size, 4])
self.actions = np.zeros([self.mem_size])
self.rewards = np.zeros([self.mem_size])
self.done = np.zeros([self.mem_size])
# Greedy behavior
self.e = 1
self.e_decay = 0.0001
def enough_mem(self):
return self.index > self.batch_size
def remember(self, state, reward, action, done, state_):
self.states[self.index%self.mem_size] = state
self.states_[self.index%self.mem_size] = state_
self.actions[self.index%self.mem_size] = action
self.rewards[self.index%self.mem_size] = reward
self.done[self.index%self.mem_size] = done
self.index += 1
def save(self):
self.model.save('pole.h5')
def predict(self, state):
if np.random.random() < self.e:
return int(np.random.choice([0, 1]))
out = self.model.predict(np.array([state]))
return 1 if out[0][1] > out[0][0] else 0
def train(self):
if not self.enough_mem():
return
self.e -= self.e_decay
self.e = 0.01 if self.e < 0.01 else self.e
indexs = np.random.randint(0, self.mem_size, size=[self.batch_size])
sample_s = [ np.array([self.states[i]]) for i in indexs ]
sample_s_ = [ np.array([self.states_[i]]) for i in indexs ]
sample_act = [ int(self.actions[i]) for i in indexs ]
sample_r = [ self.rewards[i] for i in indexs ]
sample_d = [ int(self.done[i]) for i in indexs ]
X = [ s[0] for s in sample_s ]
Y = []
for state, state_, action, reward, done in zip(sample_s, sample_s_, sample_act, sample_r, sample_d):
current_q = self.model.predict(state)[0]
next_q = self.model.predict(state_)[0]
max_q = np.amax(next_q)
current_q[action] = reward + max_q * .99 * ( 1 - done )
Y.append(current_q)
X, Y = np.array(X), np.array(Y)
self.model.fit(X, Y, epochs=1, verbose=0)
precision = true_positives / (predicted_positives + K.epsilon())
return precision
precision = precision(y_true, y_pred)
recall = recall(y_true, y_pred)
return 2*((precision*recall)/(precision+recall+K.epsilon()))
classifier.compile(loss='binary_crossentropy',
optimizer= "adam",
metrics=[f1])
classifier.fit(X_train,y_train, batch_size=1, epochs=300)
eval_model=classifier.evaluate(X_train, y_train)
print("\n\t eval_model=",eval_model)
y_pred=classifier.predict(X_test)
#print("\n\t y_test=",type(y_test),"\t y_pred=",type(y_pred))
y_pred =(y_pred>0.5)
#y_pred=pd.Series(y_pred)
'''
saving model
'''
model_json=classifier.to_json()
with open("/home/kapitsa/PycharmProjects/upwork/models//model.json","w") as json_file:
json_file.write(model_json)
val_accuracy = tumor_model_train_dropout.history['val_acc']
loss = tumor_model_train_dropout.history['loss']
val_loss = tumor_model_train_dropout.history['val_loss']
epochs = range(len(accuracy))
plt.plot(epochs, accuracy, 'bo', label='Training accuracy')
plt.plot(epochs, val_accuracy, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend()
plt.figure()
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()
plt.show()
predicted_classes = tumor_model.predict(X_test)
predicted_classes = np.argmax(np.round(predicted_classes), axis=1)
correct = np.where(predicted_classes == y_test)[0]
print("Found %d correct labels" % len(correct))
for i, correct in enumerate(correct[:9]):
plt.subplot(3, 3, i + 1)
plt.imshow(X_test[correct].reshape(28, 28),
cmap='gray',
interpolation='none')
plt.title("Predicted {}, Class {}".format(predicted_classes[correct],
y_test[correct]))
plt.tight_layout()
incorrect = np.where(predicted_classes != y_test)[0]
loss='binary_crossentropy',
metrics=['accuracy'])
callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=3)
# fit the model
model.fit(X_train,
y_train,
epochs=20,
batch_size=5000,
verbose=1,
callbacks=[],
validation_data=(X_test, y_test),
class_weight=class_weights)
res = model.predict(X_test)
#print res[:100]
bkg_acc = 0
bkg_trials = 0
sig_acc = 0
sig_trials = 0
for r, t in zip(res, y_test):
if t == 1:
sig_trials += 1
sig_acc += int(r[0] > 0.5)
else:
bkg_trials += 1
bkg_acc += int(r[0] <= 0.5)
print 'sig_acc:', sig_acc, '/', sig_trials
print 'bkg_acc:', bkg_acc, '/', bkg_trials
model.compile(loss='mean_squared_error', optimizer=SGD(lr=lr), metrics=['accuracy'])
# batch_size define speed of studying
history = model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, callbacks=[stopper], verbose=verbose)
score = model.evaluate(x_test, y_test, verbose=1)
print("Accuracy on train data\t %.f%%" % (history.history['acc'][stopper.stopped_epoch] * 100))
print("Accuracy on testing data %.f%%" % (score[1] * 100))
print("Loss on train data %.f%%" % (history.history['loss'][stopper.stopped_epoch] * 100))
gr.plot_history_separte(history, save_path_acc="ACC.png", save_path_loss="LOSS.png",
save=False, show=True)
# Visualization after training
zeros = np.zeros(int(train_size * 0.4)).reshape(x_test.shape)
ones = np.zeros(int(train_size * 0.4)).reshape(x_test.shape)
for i, el in enumerate(model.predict(x_test)):
if el >= 0.5:
ones[i] = x_test[i]
else:
zeros[i] = x_test[i]
plt.xlim(0, 1.3)
plt.ylim(0, 1)
plt.title("After training data")
plt.plot(zeros.transpose()[0], zeros.transpose()[1], '.')
plt.plot(ones.transpose()[0], ones.transpose()[1], '.')
plt.show()
# Training of the features !!
# Using Keras Neural Network !!
# Keras
from keras import Sequential
from keras.layers import Dense
classifier = Sequential()
#First Hidden Layer
classifier.add(Dense(100, activation='relu', kernel_initializer='random_normal', input_dim = 784))
#Second Hidden Layer
#classifier.add(Dense(100, activation='relu', kernel_initializer='random_normal'))
classifier.add(Dense(100, activation='relu', kernel_initializer='random_normal'))
#Output Layer
classifier.add(Dense(10, activation='softmax', kernel_initializer='random_normal'))
#Compiling the neural network
classifier.compile(optimizer ='RMSprop',loss='sparse_categorical_crossentropy', metrics =['accuracy'])
#Fitting the data to the training dataset
classifier.fit(X_train,y_train, batch_size=20, epochs= 100 )
#y_hat_xgb = model_xgb.predict(X_test)
y_hat_keras = classifier.predict(X_test)
sample_submission = []
for i in range(len(y_hat_keras)):
sample_submission.append((i+1 , np.argmax(y_hat_keras[i])))
df = pd.DataFrame(columns = ['ImageId' , 'Label'] , data = sample_submission)
df.to_csv(directory + 'sample_submission_Keras_sequential.csv', index = None)
train_data=train_data.dropna()
# print(train_data.info())
X=train_data.drop(['Y'],1).as_matrix()#7
y=train_data['Y'].as_matrix()#1
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)
model=Sequential()
model.add(Dense(14,input_shape=(7,)))
model.add(Activation('relu'))
model.add(Dense(1))
model.add((Dropout(0.3)))
model.compile(loss='mean_squared_error', optimizer='adam')
model.summary()
model.fit(X_train,y_train,epochs=10000,batch_size=16)
t=model.predict(X_test)
rate=0
for i in range(len(t)):
if t[i]==y_test[i]:
rate+=1
else:
pass
rate=1.0*rate/len(t)
print(rate)
# test_data=pd.read_csv('D:\sufe\A\contest_basic_test.tsv',sep='\t')
# test_data=test_data.dropna()
keras.metrics.Precision(name='precision'),
keras.metrics.Recall(name='recall'),
keras.metrics.AUC(name='auc'),
]
# compile the model using binary cross-entropy rather than
# categorical cross-entropy -- this may seem counterintuitive for
# multi-label classification, but keep in mind that the goal here
# is to treat each output label as an independent Bernoulli
# distribution
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=METRICS)
## Fit model for multiple labels and print accuracy
history = model.fit(X_train, Y_train, validation_data=(X_test,Y_test),batch_size=64, epochs=200)
pred = model.predict(X_test,verbose=2)
pred_proba = model.predict_proba(X_test)
pred[pred>=0.5]=1
pred[pred<0.5]=0
print('pred: ', pred)
print('Y_test: ', Y_test)
conf_mat = multilabel_confusion_matrix(Y_test,pred)
print('conf mat: ')
print(conf_mat)
# summarize history for accuracy
ExtraSensoryHelperFunctions.PlotEpochVsAcc(plt,history)
# summarize history for loss
ExtraSensoryHelperFunctions.PlotEpochVsLoss(plt,history)
plt.plot(trained.history['loss'])
plt.plot(trained.history['val_loss'])
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
plt.plot(trained.history['sensitivity'])
plt.plot(trained.history['val_sensitivity'])
plt.title('Model sensitivity')
plt.ylabel('sensitivity')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
plt.plot(trained.history['specificity'])
plt.plot(trained.history['val_specificity'])
plt.title('Model specificity')
plt.ylabel('specificity')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
cnn_Y_pred = model.predict(X_valid)
cnn_Y_pred = np.argmax(cnn_Y_pred, axis=1)
# to display prediction images in subplots
display_prediction(5,2,X_pred,cnn_Y_pred)
model = Sequential([Dense(na, input_shape=(ns, ))])
model.set_weights([np.array([[0, 0, 0], [1, 2, 3]]), np.array([0, 0, 0])])
test_size = 200
rewards = 0
x = []
y = []
for _ in range(test_size):
s = env.reset()
x.append(s[0])
i = 0
while True:
# env.render()
q_values = model.predict(np.array([s]))
s, r, done, _ = env.step(np.argmax(q_values == q_values.max()))
rewards += r
i += 1
if done:
print("solved for {} iterations".format(i))
break
y.append(-i)
print("The average reward of {} episodes is {}".format(test_size,
rewards / test_size))
plt.title("MountainCar Designed Linear Model")
plt.ylabel("Episode reward")
plt.xlabel("Initial location")
plt.scatter(x, y)
plt.show()
class QReplayNetworkModel(AbstractModel):
""" Prediction model which uses Q-learning and a neural network which replays past moves.
The network learns by replaying a batch of training moves. The training algorithm ensures that
the game is started from every possible cell. Training ends after a fixed number of games, or
earlier if a stopping criterion is reached (here: a 100% win rate).
:param class Maze game: Maze game object.
"""
def __init__(self, game, **kwargs):
super().__init__(game, **kwargs)
if kwargs.get("load", False) is False:
self.model = Sequential()
self.model.add(Dense(game.maze.size, input_shape=(2,), activation="relu"))
self.model.add(Dense(game.maze.size, activation="relu"))
self.model.add(Dense(len(actions)))
else:
self.load(self.name)
self.model.compile(optimizer="adam", loss="mse")
def save(self, filename):
with open(filename + ".json", "w") as outfile:
outfile.write(self.model.to_json())
self.model.save_weights(filename + ".h5", overwrite=True)
def load(self, filename):
with open(filename + ".json", "r") as infile:
self.model = model_from_json(infile.read())
self.model.load_weights(filename + ".h5")
def train(self, stop_at_convergence=False, **kwargs):
""" Hyperparameters:
:keyword float discount: (gamma) preference for future rewards (0 = not at all, 1 = only)
:keyword float exploration_rate: (epsilon) 0 = preference for exploring (0 = not at all, 1 = only)
:keyword float exploration_decay: exploration rate reduction after each random step (<= 1, 1 = no at all)
:keyword int episodes: number of training games to play
:keyword int sample_size: number of samples to replay for training
:return int, datetime: number of training episodes, total time spent
"""
discount = kwargs.get("discount", 0.90)
exploration_rate = kwargs.get("exploration_rate", 0.10)
exploration_decay = kwargs.get("exploration_decay", 0.995) # % reduction per step = 100 - exploration decay
episodes = kwargs.get("episodes", 10000)
sample_size = kwargs.get("sample_size", 32)
experience = ExperienceReplay(self.model, discount=discount)
# variables for reporting purposes
cumulative_reward = 0
cumulative_reward_history = []
win_history = []
start_list = list() # starting cells not yet used for training
start_time = datetime.now()
for episode in range(1, episodes + 1):
if not start_list:
start_list = self.environment.empty.copy()
start_cell = random.choice(start_list)
start_list.remove(start_cell)
state = self.environment.reset(start_cell)
loss = 0.0
while True:
if np.random.random() < exploration_rate:
action = random.choice(self.environment.actions)
else:
# q = experience.predict(state)
# action = random.choice(np.nonzero(q == np.max(q))[0])
action = self.predict(state)
next_state, reward, status = self.environment.step(action)
cumulative_reward += reward
experience.remember([state, action, reward, next_state, status])
if status in ("win", "lose"): # terminal state reached, stop episode
break
inputs, targets = experience.get_samples(sample_size=sample_size)
self.model.fit(inputs,
targets,
epochs=4,
batch_size=16,
verbose=0)
loss += self.model.evaluate(inputs, targets, verbose=0)
state = next_state
self.environment.render_q(self)
cumulative_reward_history.append(cumulative_reward)
logging.info("episode: {:d}/{:d} | status: {:4s} | loss: {:.4f} | e: {:.5f}"
.format(episode, episodes, status, loss, exploration_rate))
if episode % 5 == 0:
# check if the current model wins from all starting cells
# can only do this if there is a finite number of starting states
w_all, win_rate = self.environment.win_all(self)
win_history.append((episode, win_rate))
if w_all is True and stop_at_convergence is True:
logging.info("won from all start cells, stop learning")
break
exploration_rate *= exploration_decay # explore less as training progresses
self.save(self.name) # Save trained models weights and architecture
logging.info("episodes: {:d} | time spent: {}".format(episode, datetime.now() - start_time))
return cumulative_reward_history, win_history, episode, datetime.now() - start_time
def q(self, state):
""" Get q values for all actions for a certain state. """
return self.model.predict(state)[0]
def predict(self, state):
""" Policy: choose the action with the highest value from the Q-table.
Random choice if multiple actions have the same (max) value.
:param np.ndarray state: Game state.
:return int: Chosen action.
"""
q = self.q(state)
logging.debug("q[] = {}".format(q))
actions = np.nonzero(q == np.max(q))[0] # get index of the action(s) with the max value
return random.choice(actions)
import matplotlib.pyplot as plt
import WildCardLib
data = []
for i in range(300):
data.append([numpy.sin(i * 0.1), 0, numpy.cos(i * 0.1)])
print(data)
look_back = 20
trainX, trainY = WildCardLib.create_dataset(data, look_back)
print(trainX)
model = Sequential()
model.add(LSTM(20, input_shape=(look_back, 3)))
# model.add(Dense(100, input_dim=3, activation='relu'))
model.add(Dense(10, activation='relu'))
model.add(Dense(3))
model.compile(loss='mean_squared_error', optimizer='adam')
model.fit(trainX, trainY, epochs=2, batch_size=1, verbose=2)
trainPredict = model.predict(trainX)
new_len = int(len(trainX) * 1)
Y = WildCardLib.extended_this(model=model,
trainX=trainX[0:new_len],
trainY=trainY[0:new_len],
look_back=look_back,
multi=1.5)
# plt.plot(trainPredict)
plt.plot(Y)
plt.plot(trainY)
plt.show()
class DNN_Model(Common_Model):
'''
__init__(): 初始化神经网络
输入:
input_shape: 特征维度
num_classes(int): 标签种类数量
'''
def __init__(self, input_shape, num_classes, **params):
super(DNN_Model, self).__init__(**params)
self.input_shape = input_shape
self.model = Sequential()
self.make_model()
self.model.add(Dense(num_classes, activation='softmax'))
self.model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print(self.model.summary(), file=sys.stderr)
'''
save_model(): 将模型权重以 model_name.h5 和 model_name.json 命名存储在 /Models 目录下
'''
def save_model(self, model_name):
h5_save_path = 'Models/' + model_name + '.h5'
self.model.save_weights(h5_save_path)
save_json_path = 'Models/' + model_name + '.json'
with open(save_json_path, "w") as json_file:
json_file.write(self.model.to_json())
'''
train(): 在给定训练集上训练模型
输入:
x_train (numpy.ndarray): 训练集样本
y_train (numpy.ndarray): 训练集标签
x_val (numpy.ndarray): 测试集样本
y_val (numpy.ndarray): 测试集标签
n_epochs (int): epoch数
'''
def train(self, x_train, y_train, x_val=None, y_val=None, n_epochs=50):
acc = []
loss = []
val_acc = []
val_loss = []
if x_val is None or y_val is None:
x_val, y_val = x_train, y_train
for i in range(n_epochs):
# 每个 epoch 都随机排列训练数据
p = np.random.permutation(len(x_train))
x_train = x_train[p]
y_train = y_train[p]
history = self.model.fit(x_train, y_train, batch_size=32, epochs=1)
# 训练集上的损失值和准确率
acc.append(history.history['acc'])
loss.append(history.history['loss'])
# 验证集上的损失值和准确率
val_loss_single, val_acc_single = self.model.evaluate(x_val, y_val)
val_acc.append(val_acc_single)
val_loss.append(val_loss_single)
plotCurve(acc, val_acc, 'LSTM Accuracy', 'acc')
plotCurve(loss, val_loss, 'LSTM Loss', 'loss')
self.trained = True
'''
predict(): 识别音频的情感
输入:
samples: 需要识别的音频特征
输出:
list: 识别结果
'''
def predict(self, sample):
# 没有训练和加载过模型
if not self.trained:
sys.stderr.write("No Model.")
sys.exit(-1)
return np.argmax(self.model.predict(sample), axis=1)
def make_model(self):
raise NotImplementedError()
metrics=['accuracy'])
# Create validation set
history = model.fit(train_data,
train_labels_one_hot,
batch_size=256,
epochs=8,
verbose=2,
validation_data=(test_data, test_labels_one_hot))
# print((history.history.keys()))
# evaluate model's error
score = model.evaluate(test_data, test_labels_one_hot, verbose=0)
print("Baseline error: %.2f%%" % (100 - score[1] * 100))
# Plot a single image, its label, and inference (model prediction for label)
infer = str(np.argmax(model.predict(test_data[0].reshape(1, 784))))
labelsAndTrainingImages = list(zip(test_images, test_labels))
# Plot single image and model estimation
plot4 = plt.figure(4)
plt.axis('off')
plt.imshow(test_images[0],
cmap='gray',
interpolation='nearest',
aspect='equal')
plt.title("Label " + str(test_labels[0]) + "\n" + "Infer " + infer)
# Plot first twenty images, labels, and inferen
plot1 = plt.figure(figsize=(10, 10))
for index, (image, label) in enumerate(labelsAndTrainingImages[:20]):
plt.subplot(4, 5, index + 1)
from keras import Sequential
from keras.layers import Dense, Embedding, LSTM, SpatialDropout1D
lstm_out = 50
# create and fit the LSTM network
model = Sequential()
model.add(LSTM(lstm_out, input_shape=(100,nparam)))
model.add(Dense(output_dim=nout))
model.compile(loss='mean_squared_error', optimizer='adam', metrics = ['accuracy'])
model.fit(x_train, y_train, epochs=10, batch_size=100, verbose=2)
# Predict train values and calculate the accuracy
pred_train = normalizer.inverse_transform(model.predict(x_train))
pred_train = np.round(pred_train)
y_train_real = normalizer.inverse_transform(y_train)
aux = y_train_real==pred_train
acc_train = sum(sum(y_train_real==pred_train))/(ntrain*nout)*100
# Predict test values and calculate the accuracy
pred_test = normalizer.inverse_transform(model.predict(x_test))
pred_test = np.round(pred_test)
y_test_real = normalizer.inverse_transform(y_test)
acc_test = sum(sum(y_test_real==pred_test))/(ntest*nout)*100
print("Train accuracy: "+str(acc_train))
print("Test accuracy: "+str(acc_test))
# Export the model to json
