def main():
user_input = get_input_args()
image_datasets, dataloaders = utilfunc.create_dataloaders(
user_input.data_dir)
model = modfunc.create_model(user_input.arch,
output_size=user_input.outsize,
change_classifier=user_input.change_class,
nodes_per_hlayer=user_input.npl)
optimizer = optim.Adam(model.classifier.parameters(), lr=user_input.lr)
criterion = nn.NLLLoss()
network_training(model=model,
dataloaders=dataloaders,
epochs=user_input.epochs,
learning_rate=user_input.lr,
with_gpu=user_input.gpu)
modfunc.save_checkpoint(filename=user_input.save_dir,
model=model,
image_datasets=image_datasets,
architecture=user_input.arch,
output_size=user_input.outsize,
hidden_layers=user_input.npl,
learning_rate=user_input.lr,
optimizer=optimizer,
epochs=user_input.epochs)
def main(path_training,
path_test,
training_test_seed=None,
output_path=r"./output.csv",
model_type=MODEL_TYPE,
exclude_misc=EXC_MISC_VAL,
keep_variables=None):
"""Processes data, predicts housing prices, saves predictions.
Args:
path_training (str): Path to training data.
path_test (str): Path to test data.
training_test_seed (int, optional): Random seed for internal training/test split.
output_path ( str): Location to save predicitions
Returns:
None
"""
# Import Features
training_df = import_data.process_data(path_training)
test_df = import_data.process_data(path_test)
# Preprocess features
features, targets, test_features, _ = prep_features.main(
training_df,
test_df,
use_log=USE_LOG,
variable_combinations=keep_variables)
# Optionally pull misc value out of sale price and add back in after
targets = targets.drop(["SalePriceMiscVal"], axis=1)
if not keep_variables is None:
features = features[keep_variables]
test_features = features[keep_variables]
# Prep targets
targets = targets["SalePrice"]
my_model = model_functions.create_model(features,
targets,
ignore_features=IGNORE,
type=model_type)
model_functions.cv(my_model, features, targets)
# Export results
result_dict = model_functions.run_full_model(my_model,
features,
targets,
test_features,
exclude_misc=exclude_misc)
cs_df = result_dict["submission_df"]
if USE_LOG:
cs_df["SalePrice"] = np.exp(cs_df["SalePrice"]) - 1
export_data.export_data(cs_df, output_path)
return parser.parse_args()
arguments = get_input_args()
if arguments.gpu:
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
else:
device = "cpu"
#load datasets
loaded_datasets = load_datasets(arguments.dir)
#create the model
model = create_model(loaded_datasets['image_datasets'], arguments.arch,
arguments.hidden_units)
#train the model
criterion = nn.NLLLoss()
optimizer = optim.Adam(model.classifier.parameters(),
lr=arguments.learning_rate)
train_network(loaded_datasets['dataloaders'], model, criterion, optimizer,
arguments.epochs, device)
#save trained model
save_checkpoint(criterion, arguments.epochs, optimizer, model, arguments.arch,
arguments.save_dir)
# print("Command Line Arguments:\n dir =", arguments.dir,
# "\n arch =", arguments.arch,
# "\n learning_rate =", arguments.learning_rate,
def main(_):
with tf.device('/gpu:0'):
for regularization_type in ['Blackout', 'None', 'L1', 'L2']:
dataset_sizes = np.linspace(2500, 55000, num=22)
for size in dataset_sizes:
# Getting the appropriate dataset
print(int(size))
train_x, train_y, valid_x, valid_y, test_x, test_y = split_data(
dataset, int(size))
# Resetting the graph incase of multiple runs on the same console
tf.reset_default_graph()
for i in range(numOfTests):
num_layers = random.choice([5, 6, 7, 8, 9, 10])
num_nodes = random.choice([200, 400, 600])
num_inputs = int(train_x.shape[1])
num_steps = random.choice([50, 100, 150, 200])
regularization_scale = random.choice(
[0.01, 0.005, 0.001, 0.0005])
percent_connections_kept = random.choice([0.9, 0.95, 0.85])
num_classes = len(np.unique(train_y))
print('Test No. ' + str(i) + '/' + str(numOfTests))
print('Parameters: ' + str(size) + ',' +
regularization_type + ',' + str(num_layers) + ',' +
str(num_nodes) + ',' + str(num_steps) + ',' +
str(regularization_scale) + ',' +
str(percent_connections_kept))
# Create the model
x = tf.placeholder(tf.float32, [None, num_inputs])
y = create_model(x, num_layers, num_nodes, num_classes)
# Define loss and optimizer
y_ = tf.placeholder(tf.int64, [None])
# Retrieving weights and defining regularization penalty
weights = tf.trainable_variables()
regularization_penalty, blackout_weights = get_regularization_penalty(
weights, regularization_scale,
percent_connections_kept, regularization_type)
# Defining loss and optimizer
cross = tf.losses.sparse_softmax_cross_entropy(labels=y_,
logits=y)
loss = cross + regularization_penalty
train_step = tf.train.RMSPropOptimizer(0.001).minimize(
loss)
# Evaluate Model
correct_prediction = tf.equal(tf.argmax(y, 1), y_)
accuracy = tf.reduce_mean(
tf.cast(correct_prediction, tf.float32))
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
# Initializing session
sess = tf.InteractiveSession(config=config)
tf.global_variables_initializer().run()
# Train
# PercentageOfConnOff=[]
# LossFunctionRegu=[]
# LossFunctionCrossTrain=[]
# LossFunctionCrossValid=[]
#
numOfBatches = 50
all_batches_x, all_batches_y = get_batches(
train_x, train_y, numOfBatches)
# Train
for i in range(num_steps):
randomPick = random.randint(0, numOfBatches)
#print(str(len(all_batches_x)) + " getting " + str(randomPick))
if randomPick == 50:
randomPick = 49
currentBatchX = all_batches_x[randomPick]
currentBatchY = all_batches_y[randomPick]
sess.run(train_step,
feed_dict={
x: currentBatchX,
y_: currentBatchY
})
# Test trained model
if i % 20 == 1:
print('Accuracy: ' + str(
sess.run(accuracy,
feed_dict={
x: valid_x,
y_: valid_y
})))
# if regularization_type=='Blackout':
# currentWeights=sess.run(blackout_weights)
# part1=currentWeights>-0.01
# part2=currentWeights<0.01
# turnedOff=np.sum(np.logical_and(part1,part2))
# TotalNumOfWeights=float(currentWeights.shape[0])
# LossFunctionCrossTrain.append(sess.run(cross, feed_dict={x: train_x, y_: train_y}))
# LossFunctionCrossValid.append(sess.run(cross, feed_dict={x: valid_x, y_: valid_y}))
# LossFunctionRegu.append(sess.run(regularization_penalty))
# PercentageOfConnOff.append((TotalNumOfWeights-turnedOff)/TotalNumOfWeights)
#if regularization_type=='Blackout':
# fig = plt.figure()
# ax1 = fig.add_subplot(1, 2, 1)
# ax2 = fig.add_subplot(1, 2, 2)
# ax1.plot(PercentageOfConnOff)
# ax2.plot(LossFunctionCrossTrain,label='Cross-Entropy Train')
# ax2.plot(LossFunctionCrossValid,label='Cross-Entropy Validation')
# ax2.plot(LossFunctionRegu,label='Regularization')
# ax2.legend()
# fig.show()
accuracyVal = sess.run(accuracy,
feed_dict={
x: valid_x,
y_: valid_y
})
accuracyTest = sess.run(accuracy,
feed_dict={
x: test_x,
y_: test_y
})
tf.reset_default_graph()
store_results(dataset, regularization_type, num_layers,
num_nodes, num_steps, regularization_scale,
percent_connections_kept, accuracyVal,
accuracyTest, size)
print('Accuracy Val: ' + str(accuracyVal) +
' , Accuracy Test: ' + str(accuracyTest))
"--dropout",
help="Setting the dropout rate in the classifier",
type=float,
default=0.5)
parser.add_argument("-ep",
"--epochs",
help="Setting the dropout rate in the classifier",
type=int,
default=15)
parser.add_argument("--gpu", help="Use GPU for training", action="store_true")
args = parser.parse_args()
image_datasets, data_loaders, _ = modfunc.transform_load(args.data_directory)
model, criterion, optimizer = modfunc.create_model(
arch=args.arch,
dropout=args.dropout,
hidden_units=args.hidden_units,
learning_rate=args.learning_rate)
if args.gpu:
device = 'cuda'
else:
device = 'cpu'
modfunc.train_model(image_datasets, data_loaders, model, criterion, optimizer,
args.epochs, device)
modfunc.model_test(image_datasets, data_loaders, model, 'test', criterion,
device)
if args.save_dir:
othfunc.save_model(image_datasets,
df_test = df_data[(df_data.date >= str_test_start)
& (df_data.date <= str_test_end)]
df_train_test = pd.concat([df_train, df_test])
df_test_for_sequence = df_train_test[len(df_train_test) -
len(df_test) -
series_length:]
X_train, y_train = preprocess(df_train[selected_features],
True, predict_length,
series_length)
X_test, y_test = preprocess(
df_test_for_sequence[selected_features], False,
predict_length, series_length)
model = create_model(X_train.shape[1:])
model.compile(loss='sparse_categorical_crossentropy',
optimizer="adam",
metrics=['accuracy'])
history = model.fit(X_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=False,
validation_split=0.1)
test_score, test_accuracy = model.evaluate(
X_test, y_test, batch_size=batch_size)
test_score = round(test_score, 2)