def handWriting_test():
X_train, Y_train = input_data.loadHandwritingTrainingData(
) #X_train.shape=(1024,387) Y_train.shape=(1,387)
layer_types = ['sigmoid']
hidden_layer_dims = None
parameters = nn_model.model(X_train,
Y_train,
hidden_layer_dims,
layer_types,
learning_rate=0.1,
num_iterations=501)
Y_train_predict, train_accuracy = nn_model.predict(X_train, Y_train,
parameters,
hidden_layer_dims,
layer_types)
print('Training accuracy: %f' % train_accuracy)
X_test, Y_test = input_data.loadHandwritingTestData(
) #X_test.shape=(1024, 184) Y_train.shape=(1, 184)
Y_test_predict, test_accuracy = nn_model.predict(X_test, Y_test,
parameters,
hidden_layer_dims,
layer_types)
print(Y_test[0, :10])
print(Y_test_predict[0, :10])
print('Test accuracy: %f' % test_accuracy)
def main():
# Get input arguments
in_args = get_input_args()
#load model from checkpoint
print('Loading model from saved checkpoint...')
model = nn_model.load_checkpoint(in_args.checkpoint, in_args.gpu)
#test code
print('Testing model now...')
test_dir = 'flowers' + '/test'
test_transforms = transforms.Compose([ transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406],[0.229, 0.224, 0.225])])
test_datasets = datasets.ImageFolder(test_dir, transform = test_transforms)
testloader = torch.utils.data.DataLoader(test_datasets, batch_size =32, shuffle=True)
criterion = nn.NLLLoss()
if(in_args.gpu):
model.to('cuda')
model.eval()
with torch.no_grad():
_, accuracy, total_images = nn_model.validation(model, testloader, criterion, in_args.gpu)
print("Accuracy of network on {} images = {:.4f}".format(total_images, accuracy))
#
print('Predicting proabable name for {} input image/s and associated probabilities'.format(in_args.top_k))
probs, classes = nn_model.predict(in_args.input_image, model, in_args.top_k, in_args.gpu)
nn_model.print_predictions(probs, classes, in_args.category_names_file)
def not_mnist_test():
X, Y, Y_onehot = notMNIST_MNIST.load_notMNIST()
# X.shape = (784, 10000), Y.shape = (1, 10000), Y_onehot.shape = (10, 10000)
layer_types = [
'relu',
'softmax',
]
hidden_layer_dims = [
100,
]
parameters = nn_model.model(X,
Y_onehot,
hidden_layer_dims,
layer_types,
learning_rate=0.8,
num_iterations=101,
num_batches=10)
Y_predict, train_accuracy = nn_model.predict(X, Y_onehot, parameters,
hidden_layer_dims,
layer_types)
print('Training accuracy: %f' % train_accuracy)
image_shape = (28, 28)
sample_indices = [0, 10, 100, 200, 500, 1000, 2000, 5000, 9000]
alphabet_list = np.array([chr(i) for i in range(ord('A'), ord('J') + 1)])
print(alphabet_list[list(map(int, Y[0, sample_indices]))])
print(alphabet_list[Y_predict[0, sample_indices]])
plot.display_image_samples(X, image_shape, sample_indices)
def random_test_with_dropout_adam():
X, Y, Y_onehot=input_data.loadRandomData()
layer_types=['relu','softmax',]
hidden_layer_dims=[120,]
parameters = nn_model.model_with_dropout_adam(X, Y_onehot, hidden_layer_dims, layer_types, learning_rate=0.5, num_iterations=2001)
Y_predict, train_accuracy = nn_model.predict(X, Y_onehot, parameters, hidden_layer_dims, layer_types)
train_accuracy = np.sum(Y_predict==Y) / Y.shape[1]
print('Training accuracy: %f' % train_accuracy)
def random_test():
X, Y, Y_onehot=input_data.loadRandomData()
layer_types=['relu','softmax',]
hidden_layer_dims=[120,]
parameters = nn_model.model(X, Y_onehot, hidden_layer_dims, layer_types, learning_rate=0.5, num_iterations=2001, lambd=1.2)
Y_predict, train_accuracy = nn_model.predict(X, Y_onehot, parameters, hidden_layer_dims, layer_types)
train_accuracy = np.sum(Y_predict==Y) / Y.shape[1]
print('Training accuracy: %f' % train_accuracy)
plot.show_decision_boundry(X, Y, Y_onehot, nn_model.predict, parameters, hidden_layer_dims, layer_types)
def mnist_test():
X, Y, Y_onehot = notMNIST_MNIST.load_MINIST(10000)
# X.shape = (784, 10000), Y.shape = (1, 10000), Y_onehot.shape = (10, 10000)
layer_types=['softmax',]
hidden_layer_dims=None
parameters = nn_model.model(X, Y_onehot, hidden_layer_dims, layer_types, learning_rate=0.5, num_iterations=101, num_batches = 10)
Y_predict, train_accuracy = nn_model.predict(X, Y_onehot, parameters, hidden_layer_dims, layer_types)
print('Training accuracy: %f' % train_accuracy)
image_shape = (28,28)
sample_indices = [0,10,100,200,500,1000,2000,5000,9000]
print(Y[0,sample_indices])
print(Y_predict[0,sample_indices])
plot.display_image_samples(X, image_shape, sample_indices)
import numpy as np
import matplotlib.pyplot as plt
from testCases import *
import sklearn
import sklearn.datasets
import sklearn.linear_model
from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets
from nn_model import nn_model, predict
X, Y = load_planar_dataset()
plt.figure(figsize=(16, 32))
hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50]
for i, n_h in enumerate(hidden_layer_sizes):
plt.subplot(5, 2, i + 1)
plt.title('Hidden Layer of size %d' % n_h)
parameters = nn_model(X, Y, n_h, num_iterations=5000)
plot_decision_boundary(lambda x: predict(parameters, x.T), X,
np.squeeze(Y))
predictions = predict(parameters, X)
accuracy = float(
(np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) /
float(Y.size) * 100)
print("Accuracy for {} hidden units: {} %".format(n_h, accuracy))
x_test = x[-200:]
y_test = y[-200:]
y_org_test = y_org[-200:]
print(np.shape(x_train))
print(np.shape(y_train))
# *** train the NN model ***
train = False
if train:
nn_model.train(x_train,
y_train,
x_test,
y_test,
save_path='D:\\datasets\\Trail_NN\\trained_model/house')
# *** test and predict ***
predict = False
if predict:
test_index = 165
y_hat = nn_model.predict(x_test[test_index],
load_path='D:\\datasets\\Trail_NN\\trained_model')
cv2.imshow('img', cv2.resize(x_test[test_index], (200, 200)))
cv2.waitKey(0)
# *** evaluate the model accuracy ***
eval = True
if eval:
nn_model.evaluate(x_test,
y_org_test.tolist(),
load_path='D:\\datasets\\Trail_NN\\trained_model')
# X即特征属性值
train_X = train_np[:, 1:].T
s = len(train_X)
train_X.reshape([s, -1])
test_X = test_np.T
s = len(test_X)
test_X.reshape([s, -1])
test_Y = data_test['PassengerId'].as_matrix()
return train_X, train_Y, test_X, test_Y
if __name__ == "__main__":
X, Y, TX, TY = load_titanic_data()
print("X shape:", X.shape)
print("Y shape:", Y.shape)
parameters = nn_model.nn_model(X, Y, 14, 20000, print_cost=False)
predictions = nn_model.predict(parameters, X)
print('准确率: %d' %
float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) /
float(Y.size) * 100) + '%')
predictions = nn_model.predict(parameters, TX)
result = pd.DataFrame({
'PassengerId': TY,
'Survived': predictions.squeeze().astype(np.int32)
})
result.to_csv("data/logistic_regression_predictions.csv", index=False)
def train_net(X_train, labels_train, layer_param, lr, lr_decay, reg, mu,
max_epoch, X_val, labels_val):
weights, biases, vweights, vbiases = initialize_parameters(layer_param)
epoch = 0
data_losses = []
reg_losses = []
val_accuracy = []
train_accuracy = []
weights_update_ratio = []
biases_update_ratio = []
while epoch < max_epoch:
(hiddens, scores) = forward(X_train, layer_param, weights, biases)
val_accuracy.append(
predict(X_val, labels_val, layer_param, weights, biases))
train_accuracy.append(
predict(X_train, labels_train, layer_param, weights, biases))
data_loss = data_loss_softmax(scores, labels_train)
reg_loss = reg_L2_loss(weights, reg)
data_losses.append(data_loss)
reg_losses.append(reg_loss)
dscores = decores_softmax(scores, labels_train)
(dweights, dbiases) = gradient_backprop(dscores, hiddens, weights,
biases, reg)
weights_update_ratio.append(
nesterov_momentumSGD(vweights, weights, dweights, lr, mu))
biases_update_ratio.append(
nesterov_momentumSGD(vbiases, biases, dbiases, lr, mu))
epoch += 1
lr *= lr_decay
plt.close()
fig = plt.figure('loss')
ax = fig.add_subplot(2, 1, 1)
ax.grid(True)
ax2 = fig.add_subplot(2, 1, 2)
ax2.grid(True)
plt.xlabel('test')
plt.ylabel('accuracy log10(data loss)', fontsize=14)
ax.scatter(np.arange(len(data_losses)),
np.log10(data_losses),
c='b',
marker='.')
ax2.scatter(np.arange(len(val_accuracy) - 0),
val_accuracy[0:],
c='r',
marker='*')
ax2.scatter(np.arange(len(train_accuracy) - 0),
train_accuracy[0:],
c='g',
marker='.')
plt.show()
return data_losses, reg_losses, weights, biases, val_accuracy
def main():
# Get input arguments
in_args = get_input_args()
# Define training, validation and testing directories
train_dir = os.path.join(in_args.data_dir, 'train')
valid_dir = os.path.join(in_args.data_dir, 'valid')
test_dir = os.path.join(in_args.data_dir, 'test')
# Define training, validation and testing transforms
train_transforms = transforms.Compose([
transforms.RandomRotation(90),
transforms.RandomHorizontalFlip(),
transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
valid_transforms = transforms.Compose([
transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
test_transforms = transforms.Compose([
transforms.Resize(255),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
# Create training, validation and testing datasets
train_datasets = datasets.ImageFolder(train_dir,
transform=train_transforms)
valid_datasets = datasets.ImageFolder(valid_dir,
transform=valid_transforms)
test_datasets = datasets.ImageFolder(test_dir, transform=test_transforms)
# Define data loaders
trainloader = torch.utils.data.DataLoader(train_datasets,
batch_size=64,
shuffle=True)
validloader = torch.utils.data.DataLoader(valid_datasets,
batch_size=32,
shuffle=True)
testloader = torch.utils.data.DataLoader(test_datasets,
batch_size=32,
shuffle=True)
# Create model
model = eval('models.' + in_args.arch + '(pretrained=True)')
#Freeze pre-trained model for training
for param in model.parameters():
param.requires_grad = False
model.classifier = nn_model.Network(get_classifier_in_features(model),
102,
in_args.hidden_units,
drop_p=0.5)
# Define criterion and optimizer along with some other hyperparams
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(),
in_args.learning_rate)
epochs = in_args.epochs
print_every = 40
with active_session():
#train model
print('Training model now...')
nn_model.train(model, trainloader, validloader, criterion, optimizer,
epochs, print_every, in_args.gpu)
#test model
print('Testing model now...')
if (in_args.gpu):
model.to('cuda')
model.eval()
with torch.no_grad():
_, accuracy, total_images = nn_model.validation(
model, testloader, criterion, in_args.gpu)
print("Accuracy of network on {} images = {:.4f}".format(
total_images, accuracy))
#Test code
total_images = 0
correct = 0
for dirpath, dirnames, filenames in os.walk('flowers/test'):
for filename in filenames:
total_images += 1
input_image_path = os.path.join(dirpath, filename)
true_label = dirpath.split(os.sep)[2]
probs, classes = nn_model.predict(input_image_path, model, 1,
True)
predicted = nn_model.get_cat_to_name().get(str(classes[0]))
actual = nn_model.get_cat_to_name().get(true_label)
if actual == predicted:
print('match prediction for {}'.format(actual))
correct += 1
print('correct predictions = {}'.format(correct))
print('total images = {}'.format(total_images))
print('accuracy = {}'.format((correct / total_images) * 100.0))
#
#save model
print('Saving trained model to {}'.format(in_args.save_dir))
nn_model.save_checkpoint(in_args.arch, model, in_args.save_dir)
# plt.title("Logistic Regression")
# Print accuracy
# LR_predictions = clf.predict(X.T)
# print ('Accuracy of logistic regression: %d ' % float((np.dot(Y,LR_predictions) + np.dot(1-Y,1-LR_predictions))/float(Y.size)*100) +
# '% ' + "(percentage of correctly labelled datapoints)")
## RUN NN_MODEL ##
params = nn_model(X, Y, n_h=4, num_iter=10000, print_cost=True)
# Plot the decision boundary
# plot_decision_boundary(lambda x: predict(params, x.T), X, Y)
# plt.title("Decision Boundary for hidden layer size " + str(4))
# Print accuracy
predictions = predict(params, X)
print('Accuracy: %d' %
float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) /
float(Y.size) * 100) + '%')
## TUNING HIDDEN LAYER SIZE ##
# plt.figure(figsize=(16, 32))
hidden_layer_sizes = [1, 2, 3, 4, 5, 10, 20, 50]
for i, n_h in enumerate(hidden_layer_sizes):
# plt.subplot(5, 2, i+1)
# plt.title('Hidden Layer of size %d' % n_h)
parameters = nn_model(X, Y, n_h, num_iter=10000)
# plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)
predictions = predict(parameters, X)
accuracy = float(
(np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) /
device = torch.device('cuda:0')
if round(torch.cuda.memory_allocated(0) / 1024**3, 1) > 0.3:
device = torch.device('cuda:1')
data_dict.update({"device": device})
start = time.time()
train = Train_Model()
for grid in [
dict(zip(grid_search.keys(), v))
for v in product(*grid_search.values())
]:
if grid["out_size1"] > grid["out_size2"]:
new_args = {**data_dict, **grid}
train.train_model(**new_args)
y_pred, y_true = predict(**data_dict)
preRecF1 = classification_report(y_true,
y_pred,
target_names=['fake', 'real'])
print(preRecF1)
np.save('prediction.npy', y_pred)
np.save('ground_truth.npy', y_true)
end = time.time()
period = end - start
print("predicting took {} hour {} min {} sec".format(
period // 3600, (period % 3600) // 60, int(period % 60)))
end = time.time()
duration = end - start
print("training took {} hour {} min {} sec".format(duration // 3600,
