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))