def PNtrain(dataset: str, batch_size=30500, lr=1e-3):
if dataset == 'MNIST':
(x_train, y_train), (x_test, y_test) = MNIST()
model = MLP(n_layers=6, activation='relu', use_softmax=True)
optimizer = tf.keras.optimizers.Adam(lr=lr)
elif dataset == 'epsilon':
(x_train, y_train), (x_test, y_test) = Epsilon()
model = MLP(n_layers=6, activation='softsign', use_softmax=True)
optimizer = tf.keras.optimizers.Adam(lr=lr)
elif dataset == '20News':
(x_train, y_train), (x_test, y_test) = News20()
model = MLP(n_layers=5, activation='softsign', use_softmax=True)
optimizer = tf.keras.optimizers.Adagrad(lr=lr)
elif dataset == 'CIFAR-10':
(x_train, y_train), (x_test, y_test) = Cifar10()
model = CNN(use_softmax=True)
optimizer = tf.keras.optimizers.Adam(lr=lr)
else:
raise ValueError('Incorrect argument!')
pi_p = np.count_nonzero(y_train) / y_train.size
pi_n = 1 - pi_p
n_p = 1000
n_n = int(np.round((pi_n / 2 / pi_p)**2 * n_p))
p_index = np.random.choice(y_train.sum(), n_p)
n_index = np.random.choice(np.logical_not(y_train).sum(), n_n)
train_data_x = np.concatenate(
(x_train[y_train][p_index], x_train[np.logical_not(y_train)][n_index]))
train_data_y = np.concatenate((np.ones(n_p), np.zeros(n_n)))
train_data_x, x_test = train_data_x / 255., x_test / 255.
model.compile(optimizer=optimizer,
loss='sparse_categorical_crossentropy',
metrics=['acc'])
if os.path.isdir('logs/' + dataset + '-PN'):
print('Error: log dir exist')
exit(1)
tensorboard = tf.keras.callbacks.TensorBoard(
log_dir="logs/{}/train".format(dataset + '-PN'))
summary_writer = tf.summary.FileWriter("logs/{}/test".format(dataset +
'-PN'))
for i in range(10000):
model.fit(train_data_x,
train_data_y,
batch_size=batch_size,
epochs=i + 1,
shuffle=True,
callbacks=[tensorboard],
initial_epoch=i)
lossval, acc = model.evaluate(x_test, y_test, batch_size=batch_size)
summary = tf.Summary()
summary.value.add(tag='test-loss', simple_value=lossval)
summary.value.add(tag='test-accuracy', simple_value=acc)
summary.value.add(tag='test-error', simple_value=1 - acc)
summary_writer.add_summary(summary, i)
summary_writer.flush()
def main(_):
from tensorflow.examples.tutorials.mnist import input_data
tf.reset_default_graph()
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
config = Config()
sess = tf.Session()
mlp = MLP(config, sess)
mlp.fit(mnist.train.images, mnist.train.labels)
print("[*] Finished Training")
print("Test accuracy: {}".format(get_accuracy([mnist.test.images,
mnist.test.labels], mlp)))
return
def model_test():
# 构造训练数据
(train_data, train_lable), (test_data, test_lable) = mnist.load_data()
train_data = train_data[:1000, :, :]
# reshape 教学
train_data = train_data.reshape(
[train_data.shape[0], train_data.shape[1] * train_data.shape[2]]) / 255
train_lable = train_lable[:1000]
ANN = MLP(epoch=300, classif=True)
ANN.add(Full_connected(n_out=300, acf_fn='sigmod'))
ANN.add(Full_connected(n_out=100, acf_fn='sigmod'))
ANN.add(Full_connected(n_out=10, acf_fn='sigmod'))
model_loss, acc = ANN.fit(train_data, train_lable)
return model_loss, acc
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 4 11:33:18 2018
@author: evanderdcosta
"""
import tensorflow as tf
import os
import inspect
from model import MLP
from config import Config
if __name__ == '__main__':
from tensorflow.examples.tutorials.mnist import input_data
tf.reset_default_graph()
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
config = Config()
sess = tf.Session()
mlp = MLP(config, sess)
mlp.fit(mnist.train.images, mnist.train.labels)
def PUtrain(dataset: str, func_loss, batch_size=30500, lr=1e-3, pretrain='no'):
if dataset == 'MNIST':
(x_train, y_train), (x_test, y_test) = MNIST()
model = MLP(n_layers=6, activation='relu', use_softmax=False)
optimizer = tf.keras.optimizers.Adam(lr=lr)
elif dataset == 'epsilon':
(x_train, y_train), (x_test, y_test) = Epsilon()
model = MLP(n_layers=6, activation='softsign', use_softmax=False)
optimizer = tf.keras.optimizers.Adam(lr=lr)
elif dataset == '20News':
(x_train, y_train), (x_test, y_test) = News20()
model = MLP(n_layers=5, activation='softsign', use_softmax=False)
optimizer = tf.keras.optimizers.Adagrad(lr=lr)
elif dataset == 'CIFAR-10':
(x_train, y_train), (x_test, y_test) = Cifar10()
model = CNN(use_softmax=False)
optimizer = tf.keras.optimizers.Adam(lr=lr)
else:
raise ValueError('Error: unknown dataset')
if pretrain == 'pretrain':
# Override optimizer
optimizer = tf.keras.optimizers.Adagrad(lr=lr)
lossstr = '-pretrain'
elif func_loss is loss.puloss:
lossstr = '-uPU'
elif func_loss is loss.nnpuloss:
lossstr = '-nnPU'
elif func_loss is loss.positive_risk:
lossstr = '-pRisk'
else:
raise ValueError('Error: unknown loss')
foldername = dataset + lossstr
if os.path.isdir('logs/' + foldername):
print('Error: log dir exist')
exit(2)
# prior probability
pi_p = np.count_nonzero(y_train) / y_train.size
loss.pi_p = pi_p
# choose first 1000 samples as training samples
n_p, n_n = 1000, y_train.size
# randomly choose n_p training samples as positive samples
# the rest is unlabeled samples
p_index = np.random.choice(y_train.sum(), n_p)
train_data_x = np.concatenate((x_train[y_train][p_index], x_train))
train_data_y = np.concatenate((np.ones(n_p), np.zeros(n_n)))
# normalize the training data and the test data
train_data_x, x_test = train_data_x / 255.0, x_test / 255.0
model.compile(
optimizer=optimizer,
loss=func_loss,
metrics=['acc', loss.positive_risk, loss.negative_risk, loss.error])
# TensorBoard visualization
tensorboard = tf.keras.callbacks.TensorBoard(
log_dir="logs/{}/train".format(foldername))
summary_writer = tf.summary.FileWriter("logs/{}/test".format(foldername))
callbacks = [tensorboard]
# Pretrain related
if pretrain == 'pretrain':
saver = tf.keras.callbacks.ModelCheckpoint('checkpoint/model.ckpt',
monitor='loss',
verbose=1,
save_best_only=True,
save_weights_only=True)
callbacks.append(saver)
elif pretrain == 'finetune':
model.load_weights("checkpoint/model.ckpt")
for i in range(10000):
model.fit(train_data_x,
train_data_y,
batch_size=batch_size,
epochs=i + 1,
shuffle=True,
callbacks=callbacks,
initial_epoch=i)
lossval, acc, prisk, nrisk, err = model.evaluate(x_test,
y_test,
batch_size=batch_size)
summary = tf.Summary()
summary.value.add(tag='test-loss', simple_value=lossval)
summary.value.add(tag='test-accuracy', simple_value=acc)
summary.value.add(tag='test-positive-risk', simple_value=prisk)
summary.value.add(tag='test-negative-risk', simple_value=nrisk)
summary.value.add(tag='test-error', simple_value=err)
summary_writer.add_summary(summary, i)
summary_writer.flush()
N = 10000
M = 2000
X, y, X_t, y_t = loaddata(N, M)
time.sleep(1)
#init config
d0 = 784 #datadimension
d1 = h = 1000 #number of hidden units
d2 = C = 10 #number of classes
epoch = 20 #number of epochs
eta = 0.2 #learning rate
dur = 10
gamma = 0.0
batch = 100
num_iters = 101
#init model
model = MLP(d0, d1, d2)
time.sleep(1)
#training
model.fit(X, y, epoch, eta, gamma, dur, batch, num_iters)
model.save_checkpoint('model')
logging.info('Testing with testing data:')
y_pred = model.predict(X_t)
acc = 100 * np.mean(y_pred == y_t)
print('training accuracy', acc)
# training_data = data.iloc[:split]
# test_data = data.iloc[split:split+test_len]
print(split)
errors = []
split_tr = split # + hist_horizon
x_train = X_windows[split_tr - train_len:split_tr - horizon + 1]
x_test = X_windows[split_tr:split_tr + test_len]
y_train = Y_windows[split_tr - train_len:split_tr - horizon + 1]
y_test = Y_windows[split_tr:split_tr + test_len]
prices = y[split_tr + hist_horizon:split_tr + test_len].values
model = MLP(n_features, horizon)
model.fit(x_train, y_train, 1)
# print(x_train[-1], y_train[-1])
preds = np.zeros(len(prices))
# preds[0] = np.mean(model.predict([x_test[0]]))
for i in range(horizon, len(y_test) - horizon + 1, horizon):
# print([x_test[i - horizon]], [y_test[i - horizon]])
model.fit([x_test[i - horizon]], [y_test[i - horizon]], 5)
# print(np.mean(model.predict([x_test[i]])), model.predict([x_test[i]]))
# print(model.predict([x_test[i]]))
preds[i:i + horizon] = model.predict([x_test[i]])
preds = preds[horizon:]
last_price = prices[horizon - 1:-1]
def operation(coord, nb_epoch=10, model_dir='./model'):
model = MLP()
data_gen = DataGenerator()
model.fit(data_gen, nb_epoch, model_dir)
