def train(src, tar, pivot_num, pivot_min_times, dim):
get_data_start = time.time()
x_non_pivot, x_pivot, D = data_helper.get_data(src, tar, pivot_num,
pivot_min_times)
pivot_matrix = np.zeros((pivot_num, D))
sgd_start = time.time()
print('get data ok ---------------- time = %.3fs' %
(sgd_start - get_data_start))
# SVD decomposition based on pivot features and non-pivot features
for i in range(pivot_num):
iteration_start = time.time()
# clf = linear_model.SGDClassifier(loss = 'modified_huber', max_iter = 20, tol = 1e-3)
clf = linear_model.SGDRegressor(loss='huber', max_iter=20, tol=1e-3)
clf.fit(x_non_pivot, x_pivot[:, i])
pivot_matrix[i] = clf.coef_
# pivot_matrix[i] = clf.coef_[:, -1]
if i > 0 and i % 20 == 0:
print('SGD iteration i = %d per iteration time = %.3fs' %
(i, time.time() - iteration_start))
pivot_matrix = pivot_matrix.transpose()
sgd_end = time.time()
print('SGD optimization ok -------- time = %.3fs' % (sgd_end - sgd_start))
svd = TruncatedSVD(n_components=dim)
weight = svd.fit_transform(pivot_matrix)
data_helper.save_svd(src, tar, dim, weight)
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dataset', type=str,
choices=['ffhq', 'cifar', 'mnist', 'mnist_fashion', 'emnist'])
parser.add_argument('--image_size', type=int, choices=[32, 64, 128])
args = parser.parse_args()
latent_dim = 32
image_size = args.image_size
image_shape = [3, image_size, image_size]
batch_size = 512
train_loader, _ = data_helper.get_data(args.dataset, batch_size, image_size)
for each_distribution in ['standard_normal', 'uniform', 'gamma', 'beta', 'chi', 'laplace']:
encoder = model.Encoder(latent_dim, image_shape).cuda()
encoder.load_state_dict(torch.load(f'model/image_size_128_epoch_500_test_1/encoder_{args.dataset}_{args.image_size}_{each_distribution}'))
z_array = None
for each_batch in tqdm.tqdm(train_loader):
each_batch = Variable(each_batch[0]).cuda()
each_z_batch = encoder(each_batch)
if z_array is None:
z_array = each_z_batch.cpu().detach().numpy()
else:
z_array = np.concatenate((z_array, (each_z_batch.cpu().detach().numpy())))
print_percentage_of_data_that_is_difficult_to_generate(z_array, each_distribution)
def run_cnn(learning_rate, batch_size):
"""
Args:
- learning_rate: learning rate used to train the network.
- batch_size: batch_size to train the network.
"""
X_train, y_train, X_test, y_test = get_data()
model = CNN(n_classes=10,
learning_rate=learning_rate,
batch_size=batch_size)
print("Epoch 1...")
model.train(X_train[:50], y_train[:50])
test_network(model, X_test[:5], y_test[:5])
def __init__(self):
cf = configparser.ConfigParser()
cf.read('conf.ini', encoding="utf-8-sig")
self.mnist = data_helper.get_data()
self.num_class = int(cf.get('parm', 'num_class'))
self.height = int(cf.get('parm', 'height'))
self.dim_hidden = int(cf.get('parm', 'dim_hidden'))
self.width = int(cf.get('parm', 'width'))
self.learning_rate = float(cf.get('parm', 'learning_rate'))
self.epochs = int(cf.get('parm', 'epochs'))
self.batch_size = int(cf.get('parm', 'batch_size'))
self.display_step = int(cf.get('parm', 'display_step'))
self.model_path = os.path.join(os.getcwd(),
cf.get('parm', 'model_path'))
self.summaries_path = os.path.join(os.getcwd(),
cf.get('parm', 'summaries_path'))
def run_feedforward_network(hidden_shape, learning_rate,
is_agent_mode_enabled):
"""
Args:
- hidden shape: array of integers, the array ith element is the number of neurons for the ith layer.
- learning_rate: learning rate used to train the network.
- is_agent_mode_enabled: if true, each neuron is an instance of the class neuron. Used to give
particular behavior to neuron.
"""
X_train, y_train, X_test, y_test = get_data(reshape=True)
model = FullyConnectedNeuralNetwork(
input_shape=784,
hidden_shape=hidden_shape,
output_shape=10,
learning_rate=learning_rate,
is_agent_mode_enabled=is_agent_mode_enabled)
print("Epoch 1...")
model.train(X_train, y_train)
test_network(model, X_test, y_test)
def latent_plot(args, dataset, encoder, mapper, num=2048):
# gather x sample, E(x)
train_loader, _ = data_helper.get_data(dataset, args.batch_size,
args.image_size, args.environment)
ex_list = []
x_list = []
for each_batch in train_loader:
with torch.no_grad():
ex_list.append(encoder(each_batch[0].to(args.device)).cpu())
x_list.append(each_batch[0])
if args.batch_size * len(ex_list) >= num: break
ex_tensor = torch.cat(ex_list)
plt_list = []
#case aae. plot{E(x), Gaussian}. E(x) imitate Gaussian.
if args.model_name in ['aae', 'mask_aae']:
z = torch.randn(*ex_tensor.shape)
pca_plt = aae_latent_pca_plt(z, ex_tensor)
for i in range(z.size(1)):
plt_list.append(aae_latent_plt(z[:, i], ex_tensor[:, i], i))
#case non-prior. plot{Gaussian, M(z), E(x)} M(z) imitate E(x).
elif args.model_name in ['non-prior']:
z = torch.randn(*ex_tensor.shape)
M_z = mapper(z.to(args.device)).detach().cpu()
pca_plt = nonprior_latent_pca_plt(z, ex_tensor, M_z)
for i in range(z.size(1)):
plt_list.append(
nonprior_latent_plt(z[:, i], ex_tensor[:, i], M_z[:, i], i))
#case learning-prior. plot{Gaussian, M(z), E(x)} E(x) imitate M(z)
elif args.model_name in ['learning-prior']:
z = torch.randn(*ex_tensor.shape)
M_z = mapper(z.to(args.device)).detach().cpu()
pca_plt = learningprior_latent_pca_plt(z, ex_tensor, M_z)
for i in range(z.size(1)):
plt_list.append(
learningprior_latent_plt(z[:, i], ex_tensor[:, i], M_z[:, i],
i))
return plt_list, pca_plt
def main(args):
train_loader, _ = data_helper.get_data(args.dataset, args.batch_size,
args.image_size, args.environment)
if args.wandb:
wandb_name = "%s[%d]_%s" % (args.dataset, args.image_size,
args.model_name)
wandb.login()
wandb.init(project="AAE", config=args, name=wandb_name)
inception_model_score = load_inception_model(train_loader, args.dataset,
args.image_size,
args.environment)
ae_optimizer, d_optimizer, decoder, discriminator, encoder, g_optimizer, mapper = \
model.get_aae_model_and_optimizer(args)
if args.model_name == 'mimic':
mapper = model.Mimic(args.latent_dim, args.latent_dim,
args.mapper_inter_nz,
args.mapper_inter_layer).to(args.device)
decoder, encoder = pretrain_autoencoder(ae_optimizer, args, decoder,
encoder, train_loader)
if args.model_name == 'non-prior':
mapper, m_optimizer = model.get_nonprior_model_and_optimizer(args)
if args.model_name == 'learning-prior':
mapper, m_optimizer, discriminator_forpl, dpl_optimizer = \
model.get_learning_prior_model_and_optimizer(args)
decoder_optimizer = torch.optim.Adam(decoder.parameters(), lr=1e-4)
global start_time
start_time = time.time()
if args.pretrain_epoch > 0:
pretrain_autoencoder(ae_optimizer, args, decoder, encoder,
train_loader)
log_dict, log, log2 = {}, {}, {}
for i in range(0, args.epochs):
log_dict, log, log2 = {}, {}, {}
if args.time_limit and timeout(args.time_limit, start_time): break
encoded_feature_list = []
for each_batch in tqdm.tqdm(train_loader,
desc="train[%d/%d]" % (i, args.epochs)):
each_batch = each_batch[0].to(args.device)
if args.model_name in ['aae', 'mask_aae']:
log = model.update_aae(ae_optimizer, args, d_optimizer,
decoder, discriminator, each_batch,
encoder, g_optimizer, args.latent_dim)
elif args.model_name == 'mimic':
log, encoded_feature = \
model.update_autoencoder(ae_optimizer, each_batch, encoder, decoder, return_encoded_feature=True)
encoded_feature_list.append(encoded_feature)
elif args.model_name == 'non-prior':
log, encoded_feature = model.update_autoencoder(
ae_optimizer,
each_batch,
encoder,
decoder,
return_encoded_feature_gpu=True,
flag_retain_graph=False)
log2 = model.update_posterior_part(args, mapper, discriminator,
m_optimizer, d_optimizer,
encoded_feature)
elif args.model_name == 'learning-prior':
log = model.update_aae_with_mappedz(args, ae_optimizer,
d_optimizer, decoder,
discriminator, mapper,
each_batch, encoder,
g_optimizer)
log2 = model.update_mapper_with_discriminator_forpl(
args, dpl_optimizer, decoder_optimizer, m_optimizer,
discriminator_forpl, decoder, mapper, each_batch)
if args.model_name == 'mimic':
g_loss = model.train_mapper(args, encoder, mapper, args.device,
args.lr, args.batch_size,
encoded_feature_list)
log_dict.update(log)
log_dict.update(log2)
# wandb log를 남기고, time_check와 time_limit 옵션이 둘다 없을때만, log interval마다 기록을 남김
if args.wandb and not args.time_check and not args.time_limit:
decoder, discriminator, encoder, mapper = log_and_write_pca(
args, decoder, discriminator, encoder, i,
inception_model_score, mapper, log_dict)
# wandb log를 남기고, time_check 또는 time_limit 옵션 둘 중 하나라도 있으면, 최후에 기록을 남김
if args.wandb and (args.time_check or args.time_limit):
decoder, discriminator, encoder, mapper = log_and_write_pca(
args, decoder, discriminator, encoder, i, inception_model_score,
mapper, log_dict)
save_models(args, decoder, encoder, mapper)
if args.wandb:
wandb.finish()
def get_word2vec(content):
word2vec = Word2Vec.load('predictor/model/wiki.zh.seg_200d.model')
res = np.zeros([200])
count = 0
# word_list = content.split()
for word in content:
if word in word2vec:
res += word2vec[word]
count += 1
return pd.Series(res / count)
if __name__ == '__main__':
print('reading...')
all_text, y, label, label_to_int, int_tolabel = get_data(file='./data/train_data.csv')
print('cut text...')
train_data = cut_text(all_text)
# train_data = [line.split() for line in train_data]
print('get tfidf...')
tfidf = train_tfidf(train_data)
print('saving tfidf model')
joblib.dump(tfidf, 'model/tfidf_5000.model')
X_train, X_dev, y_train, y_dev = train_test_split(train_data, y, random_state=10, test_size=0.1)
train_vec = tfidf.transform(X_train)
test_vec = tfidf.transform(X_dev)
print('training SVC')
svm = train_SVC(train_vec, y_train)
y_pre = svm.predict(test_vec)
print(classification_report(y_dev, y_pre))
# Model parameters
EMBED_HIDDEN_SIZE = 100
BATCH_SIZE = 32
EPOCHS = 200
NUM_BLOCKS = 20
PATIENCE = 200
LRPATIENCE = 30
# Cyclic Learning Rate
# clr = clr.CyclicLR(base_lr=2e-4, max_lr=1e-2, step_size=3000., mode='triangular')
# clr = clr.CyclicLR(base_lr=0.001, max_lr=0.01, step_size=3000., mode='triangular')
# options: [triangular, triangular2, exp_range]
# --------------------------------- PREPARE DATA ---------------------------------------------------
train, test, params = data_helper.get_data(FLAGS, batch_size=BATCH_SIZE)
x, xq, y = train[0], np.expand_dims(train[1], 1), train[2]
tx, txq, ty = test[0], np.expand_dims(test[1], 1), test[2]
max_sentence_length = params["max_sentence_length"]
story_maxlen = params["story_maxlen"]
query_maxlen = params["query_maxlen"]
vocab_size = params["vocab_size"]
vocab_size += NUM_BLOCKS
# ========================================== BUILD KERAS MODEL ======================================
print('Build model...')
# ------------------------------------------ STORY INIT ---------------------------------------------
# Story
# Define input
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='This is the TextCNN test project.')
parser.add_argument(
'results_dir',
type=str,
help='The results dir including log, model, vocabulary and some images.'
)
parser.add_argument('-p',
'--padding_size',
default=200,
type=int,
help='Padding size of sentences.(default=200)')
parser.add_argument('-c',
'--num_classes',
default=95,
type=int,
help='Number of target classes.(default=95)')
args = parser.parse_args()
print('Parameters:', args)
# x_test, y_test = preprocess("./data/test_data.csv", os.path.join(args.results_dir, "vocab.json"),
# args.padding_size, test=True)
x_test, y_test = get_data('./data/baidu_95_test_x.npy',
'./data/baidu_95_test_y.npy')
print("Loading model...")
model = load_model(os.path.join(args.results_dir, 'TextCNN.h5'))
test(model, x_test, y_test)
input_x = tf.placeholder(tf.float32, [None, self.height, self.width])
rnn = MnistRnn(input_x, self.height, self.width, self.dim_hidden,
self.num_class, self.learning_rate)
saver = tf.train.Saver()
with tf.Session() as sess:
saver.restore(sess, self.model_path + 'model.ckpt')
predict = tf.argmax(rnn.pre, 1)
vector_list = sess.run(predict, feed_dict={input_x: batch_x_test})
vector_list = vector_list.tolist()
return vector_list
if __name__ == '__main__':
rnn = RNN()
if os.path.exists(os.path.join(os.getcwd(), 'ckpt', 'checkpoints')):
if not os.path.getsize(os.path.join(os.getcwd(), 'ckpt',
'checkpoints')) > 0:
print("正在训练模型.....")
rnn.train()
else:
print("正在训练模型.....")
rnn.train()
mnist = data_helper.get_data()
batch_x_test = mnist.test.images
batch_x_test = batch_x_test.reshape([-1, rnn.height, rnn.width])
batch_y_test = mnist.test.labels
batch_y_test = list(np.argmax(batch_y_test, 1))
pre_y = rnn.predict(batch_x_test)
for text in batch_y_test:
print('Label:', text, ' Predict:', pre_y[batch_y_test.index(text)])
def lazy_forward(self,
dataset,
image_size=32,
batch_size=16,
decoder=None,
distribution=None,
latent_dim=None,
real_forward=True,
device='cpu',
model_name='aae',
mapper=None,
gen_image_in_gpu=False,
environment='yhs'):
assert self.lazy, "lazy_forward only run in lazy mode. call lazy_mode() first."
train_loader, _ = data_helper.get_data(dataset, batch_size, image_size,
environment)
if real_forward:
print("generate real images info")
for each_batch in tqdm.tqdm(train_loader):
self.real_forward(each_batch[0].to(device))
else:
print("generate fake images info")
if gen_image_in_gpu:
fake_images_list = []
decoder = decoder.to(device)
if isinstance(mapper, torch.nn.Module):
mapper = mapper.to(device)
for each_batch in tqdm.tqdm(train_loader, desc='gen_fake'):
with torch.no_grad():
if model_name == "mimic":
z = torch.rand(
batch_size, latent_dim, device=device) * 2 - 1
fake_images = decoder(mapper(z))
elif model_name in ['non-prior', 'learning-prior']:
z = torch.randn(batch_size,
latent_dim,
device=device)
fake_images = decoder(mapper(z))
else:
z = torch.FloatTensor(
prior_factory.get_sample(
distribution, batch_size,
latent_dim)).to(device)
if decoder.has_mask_layer:
z = torch.mul(z, decoder.mask_vector)
fake_images = decoder(z)
fake_images_list.append(fake_images.cpu())
decoder = decoder.to('cpu')
if isinstance(mapper, torch.nn.Module):
mapper = mapper.to('cpu')
fake_predict_softmax_list, fake_feature_list = [], []
for index in tqdm.tqdm(range(len(fake_images_list)),
desc='gen_feature'):
fake_images_gpu = fake_images_list[index].to(device)
with torch.no_grad():
fake_predict_softmax, fake_feature = self.analysis_softmax_and_feature(
fake_images)
fake_predict_softmax_list.append(
fake_predict_softmax.cpu())
fake_feature_list.append(fake_feature.cpu())
fake_images_list[index] = None
self.fake_predict_softmax = torch.cat(
fake_predict_softmax_list)
self.fake_feature = torch.cat(fake_feature_list)
else:
for each_batch in tqdm.tqdm(train_loader):
if model_name == "mimic":
z = torch.rand(batch_size, latent_dim) * 2 - 1
fake_images = decoder(mapper(z)).to(device)
elif model_name == 'non-prior':
z = torch.randn(batch_size, latent_dim)
fake_images = decoder(mapper(z)).to(device)
else:
z = torch.FloatTensor(
prior_factory.get_sample(distribution, batch_size,
latent_dim))
if decoder.has_mask_layer:
z = torch.mul(z, decoder.mask_vector.cpu())
fake_images = decoder(z).to(device)
self.fake_forward(fake_images)
from keras.callbacks import LambdaCallback
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.layers import GRU, LSTM
from keras.optimizers import RMSprop
from keras.utils.data_utils import get_file
from sklearn.externals import joblib
import numpy as np
import random
import os
import sys
import re
from data_helper import get_data
text, chars, char_indices, indices_char = get_data()
# cut the text in semi-redundant sequences of maxlen characters
maxlen = 30
step = 3
sentences = []
next_chars = []
for i in range(0, len(text) - maxlen, step):
sentences.append(text[i:i + maxlen])
next_chars.append(text[i + maxlen])
print('nb sequences:', len(sentences))
print('Vectorization...')
x = np.zeros((len(sentences), maxlen, len(chars)), dtype=np.bool)
y = np.zeros((len(sentences), len(chars)), dtype=np.bool)
for i, sentence in enumerate(sentences):
import random
import os
import json
from actor import ActorNetwork
from self_att_rnn import SelfAttRNN
from model_api import ModelAPI
from integration_func import generate_embedding_mat
from data_helper import get_data, rand_batch_gen
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
metadata_pkl = './data/post_metadata.pkl'
max_length = 200
word_to_int, int_to_word, sentence_int, label, length = get_data(
metadata_pkl, max_length)
rand_batch = rand_batch_gen(sentence_int, label, length, 64)
vocab_size = len(word_to_int)
embed_size = 128
options = {"context_lstm_dims": 100, "highway_layer_num": 1}
class_list = [
u"投递质量", u"延误", u"信息质量", u"破损", u"丢失", u"服务态度", u"收寄质量", u"需求建议", u"售后服务"
]
config = {
"options": options,
"vocab_size": vocab_size,
"max_length": max_length,
"emb_size": embed_size,
Neural network regression example for JDOT
"""
# Author: Remi Flamary <*****@*****.**>
# Nicolas Courty <*****@*****.**>
#
# License: MIT License
import numpy as np
import data_helper
import jdot
from keras.utils import np_utils
import keras
import time
X, y = data_helper.get_data('supernova-src')
Xtest, ytest = data_helper.get_data('supernova-tgt')
nclasses = len(np.unique(np.hstack((y, ytest)))) + 1
n_inputs = X.shape[1]
ytest = np_utils.to_categorical(ytest, num_classes=nclasses)
y = np_utils.to_categorical(y, num_classes=nclasses)
def get_model():
# simple 1D nn
model = keras.models.Sequential()
model.add(keras.layers.Dense(80, activation='tanh', input_dim=n_inputs))
model.add(keras.layers.Dense(80, activation='tanh'))
model.add(keras.layers.Dense(y.shape[1], activation='softmax'))
model.compile(optimizer='sgd',
'--results_dir',
default='./results/',
type=str,
help=
'The results dir including log, model, vocabulary and some images.(default=./results/)'
)
args = parser.parse_args()
print('Parameters:', args, '\n')
if not os.path.exists(args.results_dir):
os.mkdir(args.results_dir)
timestamp = time.strftime("%Y-%m-%d-%H-%M", time.localtime(time.time()))
os.mkdir(os.path.join(args.results_dir, timestamp))
os.mkdir(os.path.join(args.results_dir, timestamp, 'log/'))
# if not os.path.exists("./data/train_data.csv") or not os.path.exists("./data/test_data.csv"):
# data_helper.load_data_and_write_to_file("./data/fenduan_clean.xlsx", "./data/train_data.csv",
# "./data/test_data.csv", args.test_sample_percentage)
# x_train, y_train = data_helper.preprocess('./data/baidu_95.csv',
# './data/vocab.txt',
# './data/label_95.txt')
# data_helper.preprocess('./data/baidu_95.csv', padding_size=args.padding_size)
x_train, y_train = data_helper.get_data('./data/baidu_95_train_x.npy',
'./data/baidu_95_train_y.npy')
print(x_train.shape)
print(y_train.shape)
train(x_train, y_train, args.vocab_size, args.padding_size,
os.path.join(args.results_dir, timestamp, 'TextCNN.h5'))
# Model parameters
EMBED_HIDDEN_SIZE = 100
BATCH_SIZE = 32
EPOCHS = 200
NUM_BLOCKS = 20
PATIENCE = 200
LRPATIENCE = 30
# Cyclic Learning Rate
# clr = clr.CyclicLR(base_lr=2e-4, max_lr=1e-2, step_size=3000., mode='triangular')
# clr = clr.CyclicLR(base_lr=0.001, max_lr=0.01, step_size=3000., mode='triangular')
# options: [triangular, triangular2, exp_range]
# --------------------------------- PREPARE DATA ---------------------------------------------------
train, test, params = data_helper.get_data(FLAGS, batch_size=BATCH_SIZE)
x, xq, y = train[0], np.expand_dims(train[1], 1), train[2]
tx, txq, ty = test[0], np.expand_dims(test[1], 1), test[2]
max_sentence_length = params["max_sentence_length"]
story_maxlen = params["story_maxlen"]
query_maxlen = params["query_maxlen"]
vocab_size = params["vocab_size"]
vocab_size += NUM_BLOCKS
# ========================================== BUILD KERAS MODEL ======================================
print('Build model...')
# ------------------------------------------ STORY INIT ---------------------------------------------
# Story
# Define input
