def load_CIFAR10_data():
path_data = 'E:/DATASETS/cifar-10-batches-py'
x_train, y_train, x_test, y_test = load_all(path_data)
# Split data into train, validation and test set
num_train = 9000
num_val = 1000
num_test = 1000
# Validation set will be num_val points from the original training set
mask = range(num_train, num_train + num_val)
x_val = x_train[mask]
y_val = y_train[mask]
# Training set will be the first num_train points from the original training set
mask = range(num_train)
x_train = x_train[mask]
y_train = y_train[mask]
# User the first num_test points of the original test set as out test set
mask = range(num_test)
x_test = x_test[mask]
y_test = y_test[mask]
# Preprocessing : reshape the image data into rows
x_train = x_train.reshape(num_train, -1)
x_val = x_val.reshape(num_val, -1)
x_test = x_test.reshape(num_test, -1)
# Preprocessing : subtract the mean image
# Compute the image mean based on the training data
mean_img = np.mean(x_train,
axis=0) # (9000,3072) -> (3072) all training data
# Subtract
x_train -= mean_img
x_test -= mean_img
x_val -= mean_img
return x_train, y_train, x_val, y_val, x_test, y_test
import load_data import tensorflow as tf import numpy as np import matplotlib.pyplot as plt #xtf.reset_default_graph() import os os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' ####################################################################################################### CIFAR = load_data.load_all() data = CIFAR['data'] label = CIFAR['label'] label = np.asarray(label) CIFAR = load_data.load_test() test_data = CIFAR['data'] test_label = CIFAR['label'] test_label = np.asarray(test_label) ##################################################################################################### num_training = 40000 num_validation = 10000 num_test = 10000 logs_path = '/home/naman/Repositories/CIFAR-10-Recognition/Tensorflow/examples/5' ####################################################################################################### data = np.reshape(data, (num_training + num_validation, 32, 32, 3))
arg = load_data.arg_passing(sys.argv)
try:
dataset = arg['-data']
dim = int(arg['-dim'])
saving = arg['-saving']
dataset_path = '../Dataset/Data/' + dataset + '.pkl.gz'
except:
saving = 'doc2vec_test'
dataset_path = '../Dataset/Data/' + 'kave_1' + '.pkl.gz'
dataset_path = '/Users/Morakot/Dropbox/[github]/MSR2018/model-code/dataset/data/kave_1.pkl.gz'
dim = 100
train_t, train_d, train_y, valid_t, valid_d, valid_y, test_t, test_d, test_y = load_data.load_all(dataset_path)
train_x = []
valid_x = []
test_x = []
analyzedDocument = namedtuple('AnalyzedDocument', 'words tags')
def trainDoc2vec(documents):
taggeddocuments = []
for i, text in enumerate(documents):
# words = str(text)
words = ",".join(str(c) for c in text)
words = words.split(',')
# print words
import matplotlib
# Force matplotlib to not use any Xwindows backend.
matplotlib.use('Agg')
import load_data as loader
from svm import SVMclassifier
import matplotlib.pyplot as plt
import numpy as np
plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots
plt.rcParams['image.interpolation'] = 'nearest'
plt.rcParams['image.cmap'] = 'gray'
data, label = loader.load_all()
test_data, test_label = loader.load_test()
results = {}
best_val = -1
best_svm = None
learning_rates = [5e-6] #[1e-6,5e-6,1e-5,7e-5,3e-4,6e-4,1e-3]
regularization_strengths = [1000
] #[0,1,10,1e2,1e3,1e4,1e5,1e6,1e7,1e-1,1e-2,1e-3]
batch_sizes = [600] #[32,64,128,150,300,600,1000]
for lr in learning_rates:
for rs in regularization_strengths:
for bs in batch_sizes:
model = SVMclassifier()
model.add_data(data[:48000], label[:48000], data[48000:],
label[48000:], 10)
model.InitializePars()
model.set_lr(lr)
model.set_reg(rs)
import time
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.utils.data as data
from tensorboardX import SummaryWriter
import parse
import model
import config
import evaluate
import load_data
args = parse.args
# PREPARE DATASET #
train_data, test_data, user_num, item_num, train_mat = load_data.load_all()
# construct the train and test datasets
train_dataset = load_data.NCFData(train_data, item_num, train_mat, args.num_ng,
True)
test_dataset = load_data.NCFData(test_data, item_num, train_mat, 0, False)
train_loader = data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True)
test_loader = data.DataLoader(test_dataset,
batch_size=args.test_num_ng + 1,
shuffle=False) # a batch is a testing user
# CREATE MODEL #
if config.model == 'NeuMF-pre': # load pretrained model
assert os.path.exists(config.GMF_model_path), 'lack of GMF model'
def mean_pred(y_true, y_pred):
return K.mean(y_pred) * NORM_F_PRICE * 100 * MILLION
def root_mean_squared_error(y_true, y_pred):
rmse = K.log(K.abs(y_true) +
K.epsilon()) - K.log(K.abs(y_pred) + K.epsilon())
rmse = K.sqrt(K.mean(K.square(rmse), axis=-1))
return rmse
if SEED is not None:
np.random.seed(SEED)
[train_in, train_out, prediction_in] = load_all()
input_shape = train_in.shape[1]
# Attempt 2 ---------------------------------------------------------
model = Sequential()
model.add(
Dense(20,
input_dim=input_shape,
kernel_initializer='normal',
activation='linear'))
model.add(LeakyReLU(alpha=0.15))
model.add(Dense(1, kernel_initializer='normal', activation='linear'))
model.add(LeakyReLU(alpha=0.15))
model.compile(loss=root_mean_squared_error, optimizer='rmsprop')
# Attempt 1 ---------------------------------------------------------