def loadData(data_dir='../data/'):
data = util.load_train_data(data_dir).values
# split 2 last months for testing
data_train = np.array([
d for d in data
if not (d[2].year == 2015 and (d[2].month == 6 or d[2].month == 7))
])
data_test = np.array([
d for d in data
if d[2].year == 2015 and (d[2].month == 6 or d[2].month == 7)
])
x_train = np.delete(data_train, [0, 2, 3, 4, 7, 25], axis=1)
y_train = data_train[:, 3]
std_train = data_train[:, 26]
mean_train = data_train[:, 25]
y_train_norm = (y_train - mean_train) / std_train
x_test = np.delete(data_test, [0, 2, 3, 4, 7, 25], axis=1)
mean_test = data_test[:, 25]
std_test = data_test[:, 26]
y_test = data_test[:, 3]
return x_train, y_train_norm, mean_test, std_test, x_test, y_test
def evaluate():
# TRAINING
data_train = util.load_train_data('../data/').values
x_train = np.delete(data_train, [0, 2, 3, 4, 7, 25], axis=1)
y_train = data_train[:, 3]
std_train = data_train[:, 26]
mean_train = data_train[:, 25]
y_train_norm = (y_train - mean_train) / std_train
model = linear_model.Ridge(alpha=1.0)
model.fit(x_train, y_train_norm)
# TESTING
data_test = util.load_test_data('../data/').values
x_test = np.delete(data_test, [0, 1, 3, 6, 24], axis=1)
label = data_test[:, 0]
mean_test = data_test[:, 24]
std_test = data_test[:, 25]
y_predict = model.predict(x_test)
y_predict_denorm = (y_predict * std_test) + mean_test
result = pd.DataFrame(np.c_[label, y_predict_denorm])
result.to_csv('../data/ridge_result.csv',
header=['Id', 'Sales'],
index=False)
return True
def main():
model = build_model()
model.summary()
train_images, targets = load_train_data()
train_images = train_images.reshape(-1, 28, 28, 1)
targets = to_categorical(targets, 10)
callbacks = [
EarlyStopping(monitor='val_acc', patience=3),
ModelCheckpoint('keras_convnet',
save_best_only=True,
save_weights_only=True),
]
model.fit(train_images,
targets,
batch_size=64,
epochs=100,
validation_split=0.1,
callbacks=callbacks)
model.load_weights('keras_convnet')
test_images = load_test_data()
test_images = test_images.reshape(-1, 28, 28, 1)
predictions = model.predict(test_images)
labels = np.argmax(predictions, 1)
save_predictions(labels, 'keras_convnet.csv')
def predictPerStore(k):
# initialize result array
result = np.zeros(shape=(41088, 2))
traind = util.load_train_data('../data/')
testd = util.load_test_data('../data/')
# additional features
tr, ts = preProcess(traind, testd)
ts_id = ts['Store'].unique()
for i in ts_id:
d_tr = tr[tr['Store'] == i]
# train using kfold
print('training for store id : {}'.format(i))
model = trainKFold(d_tr, k)
# predict
print('predicting for store id : {}'.format(i))
d_ts = ts[ts['Store'] == i]
# check for open or close
# predict only for open store
opened = d_ts[d_ts['Open'] == 1]
closed = d_ts[d_ts['Open'] == 0]
# x test
x_ts = opened.copy()
del x_ts['Id']
del x_ts['Store']
del x_ts['Date']
del x_ts['DayOfWeek']
del x_ts['StateHoliday']
del x_ts['Mean']
del x_ts['Std']
# sales predict
y_pred = model.predict(x_ts)
# denom
y_pred_denorm = (y_pred * opened['Std']) + opened['Mean']
for j in opened['Id']:
result[j - 1] = [j, y_pred_denorm[j - 1]]
for k in closed['Id']:
result[k - 1] = [k, 0]
print('result stored!')
print('-------------------------------')
result = pd.DataFrame(result)
result[0] = result[0].astype(int)
result.to_csv('../data/ridge_result.csv',
header=['Id', 'Sales'],
index=False)
return True
def tf_idf_words2():
train_df = load_train_data()
train_df = text_process(train_df)
df = train_df
labels = df['category'].unique()
vectorizer = TfidfVectorizer(max_features=10000,
strip_accents='unicode',
sublinear_tf=True) #0.924
vectorizer.fit(df['title'])
n_features = 50
df2 = pd.DataFrame(columns=['label', 'palavras'])
lab = []
pal = []
for label in labels:
top = get_top_n_features_tf_idf2(label, df, n_features, vectorizer)
#top = get_top_n_features_tf_idf2(label,df,n_features,vectorizer)
#top = get_top_n_features_count(label,df,n_features)
lab.append(label)
pal.append(",".join(top))
df2['label'] = lab
df2['palavras'] = pal
df2.to_csv('./tf_idf_vec2.csv', index=False)
print(df2.head())
def main():
model = ConvNet()
print(model)
images, targets = load_train_data()
train_images, val_images, train_targets, val_targets = train_test_split(images, targets, test_size=0.1)
train_images = torch.from_numpy(train_images).unsqueeze(1)
train_targets = torch.from_numpy(train_targets)
train_dataset = TensorDataset(train_images, train_targets)
train_loader = DataLoader(train_dataset, batch_size=64)
val_images = torch.from_numpy(val_images).unsqueeze(1)
val_targets = torch.from_numpy(val_targets)
val_dataset = TensorDataset(val_images, val_targets)
val_loader = DataLoader(val_dataset, batch_size=64)
optimizer = Adam(model.parameters(), lr=1e-3)
best_val_acc = -1
patience_count = 0
for epoch in range(1, 1001):
loss, acc = train_model(model, optimizer, train_loader)
val_loss, val_acc = evaluate_model(model, val_loader)
patience_count += 1
if val_acc > best_val_acc:
best_val_acc = val_acc
patience_count = 0
torch.save(model, 'pytorch_convnet')
msg = 'Epoch {:04d} - loss: {:.6g} - acc: {:.6g} - val_loss: {:.6g} - val_acc: {:.6g}'
print(msg.format(epoch, loss, acc, val_loss, val_acc))
if patience_count > 3:
break
model = torch.load('pytorch_convnet')
images = load_test_data()
images = torch.from_numpy(images).unsqueeze(1)
test_dataset = TensorDataset(images, torch.zeros(images.size(0)))
test_loader = DataLoader(test_dataset)
labels = []
for images, _ in test_loader:
images = Variable(images.float(), requires_grad=False)
outputs = model.forward(images)
labels.extend(torch.max(outputs.data, 1)[1])
save_predictions(np.array(labels), 'pytorch_convnet.csv')
def tf_idf_words():
train_df = load_train_data()
train_df = text_process(train_df)
df = train_df
labels = df['category'].unique()
n_features = 50
df2 = pd.DataFrame(columns=['label', 'palavras'])
lab = []
pal = []
for label in labels:
top = get_top_n_features_tf_idf(label, df, n_features)
#top = get_top_n_features_count(label,df,n_features)
lab.append(label)
pal.append(",".join(top))
df2['label'] = lab
df2['palavras'] = pal
df2.to_csv('./tf_idf_vec.csv', index=False)
print(df2.head())
def count_vec_words():
train_df = load_train_data()
train_df = text_process(train_df)
df = train_df
labels = df['category'].unique()
#defina quantas features quer pegar
n_features = 25
df2 = pd.DataFrame(columns=[labels])
lab = []
qtd = []
pal = []
for label in labels:
#top = get_top_n_features_tf_idf(label,df,n_features)
top = get_top_n_features_count(label, df, n_features)
pal = pal + top
df2[label] = top
df2.to_csv('./count_vec3.csv', index=False)
print(pal)
result = Counter(pal)
print(result)
print(df2.head())
import os
import sys
import logging
import pandas as pd
import numpy as np
from util import load_train_data, load_test_data, save_result
from keras.utils import np_utils
from keras.layers import Dense, Input
from keras.models import Model
train_file = os.path.join('data', 'train.csv')
test_file = os.path.join('data', 'test.csv')
x_train, y_train = load_train_data(train_file)
x_test = load_test_data(test_file)
batch_size = 100
nb_epoch = 20
hidden_units_1 = 256
hidden_units_2 = 100
y_train = np_utils.to_categorical(y_train)
input_layer = Input(shape=(784, ))
hidden_layer_1 = Dense(hidden_units_1, activation='sigmoid')(input_layer)
hidden_layer_2 = Dense(hidden_units_2, activation='sigmoid')(hidden_layer_1)
output_layer = Dense(10, activation='softmax')(hidden_layer_2)
model = Model(input_layer, output_layer)
model.compile(optimizer='sgd', loss='categorical_crossentropy')
def main():
im_rows, im_cols = 64, 64
batch_size = 64
nb_epoch = 10
random_state = 51
colors = 1
validation_size = 2 # 26 total drivers
nb_models = 10
dropout = 0
train_data, train_target, driver_id, _ = util.load_train_data(im_rows,
im_cols, colors)
drivers_list_train = drivers_list[0:nb_drivers-validation_size]
x_train, y_train, train_index = util.copy_selected_drivers(train_data, \
train_target, driver_id, drivers_list_train)
drivers_list_valid = drivers_list[nb_drivers-validation_size:nb_drivers]
x_valid, y_valid, test_index = util.copy_selected_drivers(train_data, \
train_target, driver_id, drivers_list_valid)
print 'Train: {} Valid: {}'.format(len(x_train), len(x_valid))
print 'Train drivers: {} '.format(drivers_list_train)
print 'Test drivers: {}'.format(drivers_list_valid)
models = []
predictions = np.zeros((len(y_valid), 10))
for i in range(nb_models):
if sys.argv[1] == "load":
if len(sys.argv) < 3:
print "Please enter the name of the model to load"
else:
models.append(util.read_model(sys.argv[2]+'_'+str(i)))
elif sys.argv[1] == "basic_v1":
models.append(basic_net.Basic_Net_v1(im_rows, im_cols, colors))
elif sys.argv[1] == "basic_v2":
models.append(basic_net.Basic_Net_v2(im_rows, im_cols, colors))
elif sys.argv[1] == "fancy_v1":
models.append(fancy_net.Fancy_Net_v1(im_rows, im_cols, colors))
elif sys.argv[1] == "fancy_v2":
models.append(fancy_net.Fancy_Net_v2(im_rows, im_cols, colors))
if sys.argv[1] != "load":
# shuffle the training data and remove dropout proportion
x = [x_train[j,:,:,:] for j in range(x_train.shape[0])]
y = [y_train[j,:] for j in range(y_train.shape[0])]
xy = zip(x, y)
random.shuffle(xy)
xy = xy[int(len(xy)*dropout):]
x, y = zip(*xy)
x = np.asarray(x)
y = np.asarray(y)
models[i].fit(x, y, batch_size=batch_size, \
nb_epoch=nb_epoch, verbose=1, validation_data=(x_valid, y_valid))
util.save_model(models[i], sys.argv[1]+'_'+str(im_rows)+'_'+str(i))
softmax = models[i].predict(x_valid, batch_size=128, verbose=1)
for j in range(len(y_valid)):
predictions[j, np.argmax(softmax[j])] += 1
top1 = 0
for i in range(len(y_valid)):
if np.argmax(y_valid[i]) == np.argmax(predictions[i, :]):
top1 += 1
top1 /= float(len(y_valid))
print 'Final top 1 accuracy: {}, rows: {} cols: {} epoch: {}'\
.format(top1, im_rows, im_cols, nb_epoch)
import os
import sys
import logging
import numpy as np
from util import load_train_data, load_test_data
from keras.utils import np_utils
from keras.layers import Dense, Input, Conv2D, Reshape, Dropout, MaxPooling2D, Flatten
from keras.models import Model
from keras.preprocessing.image import ImageDataGenerator
from sklearn.metrics import precision_score, recall_score, accuracy_score, f1_score
x_train, y_train = load_train_data('cifar-10')
x_test, y_test = load_test_data(os.path.join('cifar-10', 'test_batch'))
x_train = np.reshape(x_train, (x_train.shape[0], 32, 32, 3))
x_test = np.reshape(x_test, (x_test.shape[0], 32, 32, 3))
print(x_train.shape)
print(y_train.shape)
print(x_test.shape)
print(y_test.shape)
y_train = np_utils.to_categorical(y_train)
batch_size = 32
num_classes = 10
epochs = 100
def main():
# Placeholders
images = tf.placeholder(tf.float32, [None, 28, 28])
targets = tf.placeholder(tf.int32, [None, 10])
keep_prob = tf.placeholder(tf.float32)
# Weights
W_conv1 = weight_variable([3, 3, 1, 16])
b_conv1 = bias_variable([16])
W_conv2 = weight_variable([3, 3, 16, 32])
b_conv2 = bias_variable([32])
hidden_units = (7 * 7 * 32 + 10) // 2
W_hidden = weight_variable([7 * 7 * 32, hidden_units])
b_hidden = bias_variable([hidden_units])
W_output = weight_variable([hidden_units, 10])
b_output = bias_variable([10])
weights = [
W_conv1,
b_conv1,
W_conv2,
b_conv2,
W_hidden,
b_hidden,
W_output,
b_output,
]
# Forward
x = tf.reshape(images, [-1, 28, 28, 1])
x = max_pool(tf.nn.relu(conv2d(x, W_conv1) + b_conv1))
x = max_pool(tf.nn.relu(conv2d(x, W_conv2) + b_conv2))
x = tf.reshape(x, [-1, 7 * 7 * 32])
x = tf.nn.dropout(x, keep_prob)
x = tf.nn.relu(tf.matmul(x, W_hidden) + b_hidden)
x = tf.nn.dropout(x, keep_prob)
outputs = tf.matmul(x, W_output) + b_output
# Loss
loss = tf.reduce_mean(
tf.nn.softmax_cross_entropy_with_logits(logits=outputs,
labels=targets))
optimizer = tf.train.AdamOptimizer(1e-3).minimize(loss)
# Accuracy
correct = tf.equal(tf.argmax(outputs, 1), tf.argmax(targets, 1))
accuracy = tf.reduce_mean(tf.cast(correct, tf.float32))
with tf.Session() as sess:
batch_size = 64
# Training
sess.run(tf.global_variables_initializer())
saver = tf.train.Saver(weights, max_to_keep=1)
X, y = load_train_data()
y = one_hot(y)
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.1)
best_val_acc = -1
patience_count = 0
for epoch in range(1, 1001):
X_train, y_train = shuffle(X_train, y_train)
X_batches = np.array_split(X_train, X_train.shape[0] // batch_size)
y_batches = np.array_split(y_train, y_train.shape[0] // batch_size)
loss_sum = acc_sum = 0.0
for X_batch, y_batch in zip(X_batches, y_batches):
loss_batch, acc_batch, _ = sess.run(
[loss, accuracy, optimizer],
feed_dict={
images: X_batch,
targets: y_batch,
keep_prob: 0.5
})
loss_sum += loss_batch * X_batch.shape[0]
acc_sum += acc_batch * X_batch.shape[0]
acc = acc_sum / X.shape[0]
X_batches = np.array_split(X_val, X_val.shape[0] // batch_size)
y_batches = np.array_split(y_val, y_val.shape[0] // batch_size)
acc_sum = 0.0
for X_batch, y_batch in zip(X_batches, y_batches):
acc_batch = sess.run(accuracy,
feed_dict={
images: X_batch,
targets: y_batch,
keep_prob: 1.0
})
acc_sum += acc_batch * X_batch.shape[0]
val_acc = acc_sum / X_val.shape[0]
patience_count += 1
if val_acc > best_val_acc:
best_val_acc = val_acc
patience_count = 0
saver.save(sess, 'tensorflow_convnet')
msg = 'Epoch {:04d} - loss: {:.6g} - acc: {:.6g} - val_acc: {:.6g}'
print(msg.format(epoch, loss_sum / X.shape[0], acc, val_acc))
if patience_count > 3:
break
# Prediction
saver.restore(sess, 'tensorflow_convnet')
X = load_test_data()
X_batches = np.array_split(X, X.shape[0] // batch_size)
labels = []
for X_batch in X_batches:
y = sess.run(outputs, feed_dict={images: X_batch, keep_prob: 1.0})
labels.extend(np.argmax(y, 1))
save_predictions(np.array(labels), 'tensorflow_convnet.csv')
from util import text_process4, text_process_soft, text_process, text_process2
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.preprocessing import LabelEncoder
import numpy as np
from sklearn import metrics
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import CountVectorizer
import pandas as pd
from sklearn.linear_model import SGDClassifier
from imblearn.combine import SMOTETomek
from sklearn.metrics import f1_score
from imblearn.under_sampling import TomekLinks
from scipy.sparse import coo_matrix, hstack
train_df = load_train_data()
train_df = text_process_soft(train_df)
test_df = load_test_resp()
test_df = text_process_soft(test_df)
test_df = test_df[test_df['category'] != 'erro']
#vetorizando o conjunto de treino
vectorizer = TfidfVectorizer(max_features=15000,
strip_accents='unicode',
sublinear_tf=True) #0.924
#vectorizer = CountVectorizer(max_features=30000,max_df=0.20)#0.924
print("Iniciando Vetorização...")
encoder = LabelEncoder()
X = vectorizer.fit_transform(train_df['title'])
y = encoder.fit_transform(train_df['category'])
def train():
TIMESTAMP = "{0:%Y-%m-%d-%H-%M/}".format(datetime.now())
log.log_info('program start')
data, num_good, num_bad = util.load_train_data(num_data // 2)
log.log_debug('Data loading completed')
# resample
data, length = util.resample(data, 600)
data = util.reshape(data, length)
good_data_origin = data[:num_good, :]
bad_data_origin = data[num_good:, :]
# extract bad data for test and train
permutation = list(np.random.permutation(len(bad_data_origin)))
shuffled_bad_data = bad_data_origin[permutation, :]
test_bad_data = shuffled_bad_data[:int(num_bad * 0.3), :]
train_bad_data_origin = shuffled_bad_data[int(num_bad * 0.3):, :]
# extract corresponding good data for test and train
permutation = list(np.random.permutation(len(good_data_origin)))
shuffled_good_data = good_data_origin[permutation, :]
test_good_data = shuffled_good_data[:len(test_bad_data), :]
train_good_data = shuffled_good_data[len(test_bad_data):, :]
assert len(test_bad_data) == len(test_good_data)
# construct test data
test_y = np.array([1.] * len(test_good_data) + [0.] * len(test_bad_data), dtype=np.float).reshape(
(len(test_bad_data) + len(test_good_data), 1))
test_x = np.vstack((test_good_data, test_bad_data))
# expand the number of bad data for train
train_x = np.vstack((train_good_data, train_bad_data_origin))
train_y = np.array([1.] * len(train_good_data) + [0.] * len(train_bad_data_origin), dtype=np.float).reshape(
(len(train_bad_data_origin) + len(train_good_data), 1))
train_x, train_y, num_expand = util.expand(train_x, train_y)
# regularize
for i in range(len(train_x)):
train_x[i, :, 0] = util.regularize(train_x[i, :, 0])
train_x[i, :, 1] = util.regularize(train_x[i, :, 1])
train_x[i, :, 2] = util.regularize(train_x[i, :, 2])
for i in range(len(test_x)):
test_x[i, :, 0] = util.regularize(test_x[i, :, 0])
test_x[i, :, 1] = util.regularize(test_x[i, :, 1])
test_x[i, :, 2] = util.regularize(test_x[i, :, 2])
# random
train_x, train_y = util.shuffle_data(train_x, train_y)
log.log_debug('prepare completed')
log.log_info('convolution layers: ' + str(conv_layers))
log.log_info('filters: ' + str(filters))
log.log_info('full connected layers: ' + str(fc_layers))
log.log_info('learning rate: %f' % learning_rate)
log.log_info('keep prob: ' + str(keep_prob))
log.log_info('the number of expanding bad data: ' + str(num_expand))
log.log_info('mini batch size: ' + str(mini_batch_size))
if mini_batch_size != 0:
assert mini_batch_size <= len(train_x)
cnn = Cnn(conv_layers, fc_layers, filters, learning_rate)
(m, n_W0, n_C0) = train_x.shape
n_y = train_y.shape[1]
# construction calculation graph
cnn.initialize(n_W0, n_C0, n_y)
cost = cnn.cost()
optimizer = cnn.get_optimizer(cost)
predict, accuracy = cnn.predict()
init = tf.global_variables_initializer()
saver = tf.train.Saver()
with tf.Session() as sess:
# log for tensorboard
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter("resource/tsb/train/" + TIMESTAMP, sess.graph)
test_writer = tf.summary.FileWriter("resource/tsb/test/" + TIMESTAMP)
if enable_debug:
sess = tf_debug.LocalCLIDebugWrapperSession(sess)
sess.run(init)
for i in range(1, num_epochs + 1):
if mini_batch_size != 0:
num_mini_batches = int(m / mini_batch_size)
mini_batches = util.random_mini_batches(train_x, train_y, mini_batch_size)
cost_value = 0
for mini_batch in mini_batches:
(mini_batch_x, mini_batch_y) = mini_batch
_, temp_cost = sess.run([optimizer, cost], feed_dict={cnn.x: mini_batch_x, cnn.y: mini_batch_y,
cnn.keep_prob: keep_prob})
cost_value += temp_cost
cost_value /= num_mini_batches
else:
_, cost_value = sess.run([optimizer, cost],
feed_dict={cnn.x: train_x, cnn.y: train_y, cnn.keep_prob: keep_prob})
# disable dropout
summary_train, train_accuracy = sess.run([merged, accuracy],
feed_dict={cnn.x: train_x, cnn.y: train_y,
cnn.keep_prob: 1})
summary_test, test_accuracy = sess.run([merged, accuracy],
feed_dict={cnn.x: test_x, cnn.y: test_y, cnn.keep_prob: 1})
train_writer.add_summary(summary_train, i - 1)
test_writer.add_summary(summary_test, i - 1)
if print_detail and (i % 10 == 0 or i == 1):
info = '\nIteration %d\n' % i + \
'Cost: %f\n' % cost_value + \
'Train accuracy: %f\n' % train_accuracy + \
'Test accuracy: %f' % test_accuracy
log.log_info(info)
# stop when test>0.95 and train>0.99
if test_accuracy >= 0.95 and train_accuracy >= 0.99:
info = '\nIteration %d\n' % i + \
'Cost: %f\n' % cost_value + \
'Train accuracy: %f\n' % train_accuracy + \
'Test accuracy: %f' % test_accuracy
log.log_info(info)
saver.save(sess, "resource/model/" + TIMESTAMP)
break
saver.save(sess, "resource/model/" + TIMESTAMP)
train_writer.close()
test_writer.close()
log.log_info('program end')
def main():
im_rows, im_cols = 64, 64
batch_size = 64
nb_epoch = 15
random_state = 51
colors = 1
validation_size = 2 # 26 total drivers
n_neighbors = 5 # Number of neighbors for KNN
train_data, train_target, driver_id, _ = util.load_train_data(
im_rows, im_cols, colors)
drivers_list_train = drivers_list[0:nb_drivers - validation_size]
x_train, y_train, train_index = util.copy_selected_drivers(train_data, \
train_target, driver_id, drivers_list_train)
drivers_list_valid = drivers_list[nb_drivers - validation_size:nb_drivers]
x_valid, y_valid, test_index = util.copy_selected_drivers(train_data, \
train_target, driver_id, drivers_list_valid)
print 'Train: {} Valid: {}'.format(len(x_train), len(x_valid))
print 'Train drivers: {} '.format(drivers_list_train)
print 'Test drivers: {}'.format(drivers_list_valid)
if sys.argv[1] == "load":
if len(sys.argv < 3):
print "Please enter the name of the model to load"
else:
model = util.read_model(sys.argv[2])
elif sys.argv[1] == "basic_v1":
model = basic_net.Basic_Net_v1(im_rows, im_cols, colors)
elif sys.argv[1] == "basic_v2":
model = basic_net.Basic_Net_v2(im_rows, im_cols, colors)
elif sys.argv[1] == "fancy_v1":
model = fancy_net.Fancy_Net_v1(im_rows, im_cols, colors)
elif sys.argv[1] == "fancy_v2":
model = fancy_net.Fancy_Net_v2(im_rows, im_cols, colors)
if sys.argv[1] != "load":
model.fit(x_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, \
verbose=1, validation_data=(x_valid, y_valid))
util.save_model(model, sys.argv[1] + '_' + str(im_rows))
score = model.evaluate(x_valid, y_valid, verbose=0)
predictions_valid = model.predict(x_valid, batch_size=128, verbose=1)
top1 = 0
for i in range(len(y_valid)):
if np.argmax(y_valid[i]) == np.argmax(predictions_valid[i]):
top1 += 1
top1 /= float(len(y_valid))
print 'Final log_loss: {}, top 1 accuracy: {}, rows: {} cols: {} epoch: {}'\
.format(score, top1, im_rows, im_cols, nb_epoch)
# K-Nearest Neighbors
interm_layer_model = util.build_interm_model(model)
interm_train = interm_layer_model.predict(x_train, batch_size=batch_size, \
verbose=1)
knn = KNeighborsClassifier(n_neighbors=n_neighbors)
knn.fit(interm_train, y_train)
interm_valid = interm_layer_model.predict(x_valid,
batch_size=128,
verbose=1)
knn_predictions = knn.predict(interm_valid)
knn_score = 0
for i in range(len(y_valid)):
if np.argmax(y_valid[i]) == np.argmax(knn_predictions[i]):
knn_score += 1
knn_score /= float(len(y_valid))
print 'K Nearest Neighbors accuracy with {} neighbors: {}'\
.format(n_neighbors, knn_score)
gen_imgs = 0.5 * gen_imgs + 0.5
fig, axs = plt.subplots(r, c)
cnt = 0
for i in range(r):
for j in range(c):
axs[i, j].imshow(gen_imgs[cnt, :, :, 0], cmap='gray')
axs[i, j].axis('off')
cnt += 1
fig.savefig("images/%d.png" % epoch)
plt.close()
train_file = os.path.join('data', 'train.csv')
x_train, y_train = load_train_data(train_file, normalize=False)
x_train = (x_train.astype(np.float32) - 127.5) / 127.5
x_train = np.reshape(x_train, (x_train.shape[0], 28, 28, 1))
batch_size = 32
epochs = 4000
latent_dim = 100
sample_interval = 50
channels = 1
n_critic = 5
clip_value = 0.01
optimizer = RMSprop(lr=0.00005)
valid = -np.ones((batch_size, 1))
fake = np.ones((batch_size, 1))
