def create_model(sess, FLAGS, mode):
"""Create model only used for train mode.
"""
if FLAGS.model == "vallina":
model = LinearModel(FLAGS, mode)
model.build()
else:
pass
# other model
# create task file
model_path = os.path.join(FLAGS.logdir, FLAGS.task_name)
if not os.path.exists(model_path):
os.makedirs(model_path)
print("Save model to {}".format(model_path))
elif (FLAGS.reset):
shutil.rmtree(model_path)
os.makedirs(model_path)
print("Remove existing model at {} and restart.".format(model_path))
else:
raise ValueError("Fail to create the new model.")
# Save the current configurations
config = dict(FLAGS.__flags.items())
with open("/".join([model_path, "config.json"]), "w") as file:
json.dump(config, file)
# initialize variables
sess.run(tf.global_variables_initializer())
return model
def __init__(self,
checkpoint_name,
num_classes,
num_input_features,
max_epochs=100,
lr=1e-2,
weight_decay=5e-2):
self.checkpoint_name = checkpoint_name
self.checkpoint_dir = os.path.join(CHECKPOINT_DIR,
self.checkpoint_name)
if not os.path.exists(self.checkpoint_dir):
os.makedirs(self.checkpoint_dir)
self.max_epochs = max_epochs
self.epoch = 0
self.lr = lr
self.weight_decay = weight_decay
self.num_classes = num_classes
self.num_input_features = num_input_features
self.model = LinearModel(num_classes=self.num_classes,
num_input_features=self.num_input_features)
self.loss_fn = nn.CrossEntropyLoss()
self.optimizer = optim.Adam(self.model.parameters(),
lr=self.lr,
amsgrad=True,
weight_decay=weight_decay)
# self.log_dir = os.path.join(LOG_DIR, self.checkpoint_name)
self.log_writer = tensorboardX.SummaryWriter('logs/' +
self.checkpoint_name)
self.load_checkpoint('model.pt')
def train(args):
os.makedirs(args.ckpt_dir, exist_ok=True)
writer = SummaryWriter('log')
dataloader = create_dataloader(args.train_data, args.batch_size, train=True)
model = LinearModel(args.input_size)
optimizer = torch.optim.Adam(model.parameters(), lr=args.lr, betas=(args.b1, args.b2))
criterion = torch.nn.MSELoss()
tqdm.write('[*] Start training')
step = 0
epoch_bar = tqdm(range(args.n_epochs), desc='[Total Progress]', dynamic_ncols=True, leave=False, position=0)
for epoch in epoch_bar:
batch_bar = tqdm(dataloader, desc='[Train epoch {:2}]'.format(epoch), dynamic_ncols=True, leave=False, position=1)
for i, data in enumerate(batch_bar):
feature, label = data['feature'], data['label']
optimizer.zero_grad()
#encoded, decoded = model(feature)
pred = model(feature)
loss = criterion(pred, label)
loss.backward()
optimizer.step()
hitRate = hit_rate(pred, label)
#hitRate = 0
if (step % 100 == 0):
batch_bar.set_description('[Batch {}/{}] loss: {} hit_rate: {}'.format(i, len(dataloader), loss, hitRate))
writer.add_scalar('Loss', loss, step)
if (step % args.save_fq == 0):
save_path = os.path.join(args.ckpt_dir, '{}.ckpt'.format(step))
save_model(model, save_path)
step += 1
tqdm.write('[*] Finish training')
return
def create_model(sess, FLAGS, mode):
model = LinearModel(FLAGS, mode)
model.build()
# initialize variables
sess.run(tf.global_variables_initializer())
return model
def optimize(self, initial_weight, steps):
w = initial_weight
last_all_equal = False
for i in range(steps):
#if (last_all_equal):
# sigma = sigma + 0.1
# print('New sigma is', sigma)
#elif (sigma > initial_sigma):
# sigma = sigma - 0.1
# print('New sigma is', sigma)
N = np.random.randn(npop, LinearModel.weight_count)
#N[0] = np.zeros((observation_size + 1) * action_size) # Always try the initial vector
R = np.zeros(npop)
F = np.zeros(npop)
for j in range(npop):
w_try = w + sigma * N[j]
agent = LinearModel(w_try)
R[j], actions, F[j], won = task.computeReward(agent, False)
#print(R[j], w_try, j, i, summarize_actions(actions), won)
#if (won):
# _, _, _ = computeReward(agent, render=True)
best_vector_index = np.argmax(R)
if i % 100 == 0:
reward, actions, frames, _ = task.computeReward(
LinearModel(w + sigma * N[best_vector_index]), True)
print(reward, frames, i, task.summarize_actions(actions))
print("break")
mean = np.mean(R)
#if (mean <= -10000):
# Use frame count as the target function instead of the reward.
# R = F
# mean = np.mean(R)
stdDev = np.std(R)
if (stdDev == 0):
print("All equal")
if (won):
task.close()
break
# Set a new random starting position
#w = np.random.randn(LinearModel.weight_count)
#last_all_equal = True
else:
last_all_equal = False
A = (R - mean) / np.std(R)
w = w + alpha / (npop * sigma) * np.dot(N.T, A)
if ((i + 1) % 25 == 0):
print("Mean", mean, won, i, repr(w))
else:
dist = np.linalg.norm(w - initial_weight)
print("Mean", mean, "Best", R[best_vector_index], won,
dist, i)
print(w)
return w + sigma * N[best_vector_index], R[best_vector_index]
def load_model(sess, saved_path):
class Config:
def __init__(self, **entries):
self.__dict__.update(entries)
# Load configuration from trained model
with open("/".join([saved_path, "config.json"]), "r") as file:
saved = json.load(file)
print ("Configuration recoverd:")
pprint (saved)
config = Config(**saved)
if config.model == "vallina":
model = LinearModel(config, "inference")
model.build()
else:
pass
# other model
print ("Restore from previous results...")
ckpt = tf.train.get_checkpoint_state(saved_path)
if ckpt and tf.train.checkpoint_exists(ckpt.model_checkpoint_path):
print ("saved path: {}".format(saved_path))
model.restore(sess, saved_path)
print ("Model reloaded from {}".format(ckpt.model_checkpoint_path))
else:
raise ValueError("CAN NOT FIND CHECKPOINTS EXISTS!")
return model
def __init__(self, state_size, action_size, seed, opts={}):
"""Initialise the agent
Params
======
state_size (int): dimension of each state
action_size (int): dimension of each action
seed (int): Random seed
opts (dict): optional settings
BUFFER_SIZE (long): Max size for replay buffer
BATCH_SIZE (int): Sample size of experiences from replay buffer
GAMMA (float): discount factor
TAU (float): soft update of target parameters
LR (float): optimizer learning rate
UPDATE_EVERY (int): how ofter to update the network
"""
self.state_size = state_size
self.action_size = action_size
self.seed = random.seed(seed)
self.local_network = LinearModel(state_size, action_size, seed).to(device)
self.fixed_network = LinearModel(state_size, action_size, seed).to(device)
# Overwrite the default parameters
self.buffer_size = opts['BUFFER_SIZE'] if 'BUFFER_SIZE' in opts else BUFFER_SIZE
self.batch_size = opts['BATCH_SIZE'] if 'BATCH_SIZE' in opts else BATCH_SIZE
self.gamma = opts['GAMMA'] if 'GAMMA' in opts else GAMMA
self.tau = opts['TAU'] if 'TAU' in opts else TAU
self.lr = opts['LR'] if 'LR' in opts else LR
self.update_every = opts['UPDATE_EVERY'] if 'UPDATE_EVERY' in opts else UPDATE_EVERY
self.optim = optim.Adam(self.local_network.parameters(), lr=self.lr)
# Initialize replay buffer
self.memory = ReplayBuffer(self.buffer_size, self.batch_size, seed)
# Initialize time step (for updating every UPDATE_EVERY steps)
self.t_step = 0
self.history = defaultdict(list)
def test(args):
dataloader = create_dataloader(args.test_data, args.batch_size, train=False)
model = LinearModel(args.input_size)
load_model(model, os.path.join(args.ckpt_dir, '{}.ckpt'.format(args.step)))
output_csv = open(args.test_output, 'w')
output_writer = csv.writer(output_csv)
output_writer.writerow(['building_id', 'total_price'])
tqdm.write('[*] Start testing')
step = 0
batch_bar = tqdm(dataloader, desc='[Testing]', dynamic_ncols=True, leave=False)
for i, data in enumerate(batch_bar):
id, feature, label = data['id'], data['feature'], data['label']
pred = model(feature)
batch_bar.set_description('[Testing] [Batch {}/{}]'.format(i, len(dataloader)))
for i, p in enumerate(pred): output_writer.writerow([id[i], p.item()])
#print(pred)
tqdm.write('[*] Finish testing')
def grid_search(params_grid, X, Y, linear_model: LinearModel):
linear_model_cv = GridSearchCV(linear_model.get_model(),
params_grid,
iid=False,
cv=5)
linear_model_cv.fit(X, Y)
print("Best parameters set found on development set:")
print()
print(linear_model_cv.best_params_)
print()
print("Grid scores on development set:")
print()
means = linear_model_cv.cv_results_['mean_test_score']
stds = linear_model_cv.cv_results_['std_test_score']
for mean, std, params in zip(means, stds,
linear_model_cv.cv_results_['params']):
print("%0.3f (+/-%0.03f) for %r" % (mean, std * 2, params))
print()
return linear_model_cv.best_params_
def main():
try:
parser = parse.parseCV(cli.__version__)
options, args = parser.parse_args()
if len(args) < 1 or len(args) > 1:
parser.error("Incorrect number of arguments. ")
verbose = options.verbose
fname = args[0]
ds = MemoryDataset.load(fname, verbose=verbose)
if len(ds.classes) > 2:
model = GeneralizedLinearModel(ds.dim,
len(ds.classes),
biasterm=options.biasterm)
else:
model = LinearModel(ds.dim, biasterm=options.biasterm)
if options.epochs == -1:
options.epochs = math.ceil(10**6 / ((options.nfolds - 1) *
(ds.n / options.nfolds)))
print "epochs: ", options.epochs
trainer = cli.create_trainer(options)
print("%s %s" % ("Fold".ljust(5), "Error"))
err = crossvalidation(ds,
trainer,
model,
nfolds=options.nfolds,
shuffle=options.shuffle,
error=eval.errorrate,
verbose=options.verbose,
seed=options.seed)
print("%s %s (%.2f)" % ("avg".ljust(5),
("%.2f" % np.mean(err)).rjust(5), np.std(err)))
except Exception, exc:
print "[ERROR] ", exc
from flask import flask
from flask_restful import reqparse, abort, Api, Resource
import pickle
import numpy as np
from model import LinearModel
app = Flask(__name__)
api = Api(app)
model = LinearModel()
clf_path = 'lib/models/LinearModel.pkl'
with open(clf_path, 'rb') as f:
model.clf = pickle.load(f)
parser = reqparse.RequestParser()
parser.add_argument('query')
class PredictEnergy(Resource):
def get(self):
args = parser.parse_args()
user_query = args['query']
uq_vectorized = model.vectorizer_transform(
np.array([user_query]))
prediction = model.predict(uq_vectorized)
use_canonical = args.use_canonical
use_resnet50 = args.use_resnet50
use_2d_scale = args.use_2d_scale
if exp_type == '2d3d':
# 2D to 3D keypoint lifting using GT 2D pose
if use_dataset == 'H36m':
validation_dataset = H36MDataset(dataset_root, subset='test', without_image=True, use_pcl=use_pcl, \
calculate_scale_from_2d=use_2d_scale, use_slant_compensation=use_slant_compensation)
else:
# val_path = os.path.join(dataset_root, 'val')
val_path = dataset_root
validation_dataset = MpiInf3dDataset(val_path, without_image=True, use_pcl=use_pcl, \
calculate_scale_from_2d=use_2d_scale, use_slant_compensation=use_slant_compensation)
model = model = LinearModel()
model.to(device)
model.apply(weight_init)
else:
if use_dataset == 'H36m':
validation_dataset = H36MDataset(dataset_root, subset='test', without_image=False, use_pcl=use_pcl, \
calculate_scale_from_2d=use_2d_scale, use_slant_compensation=use_slant_compensation)
if use_canonical:
num_joints = 17
else:
num_joints = 32
else:
validation_dataset = MpiInf3dDataset(val_path, without_image=False, use_pcl=use_pcl, \
database = "../resources/database/bug_reports.db"
database = path.abspath(database)
sampler = Sampler.DbSampler(database, 'training_set', 'validation_set',
'test_set')
# obtain training and test data
X_train, y_train = sampler.getTrainingData()
X_validation, y_validation = sampler.getValidationData()
X_test, y_test = sampler.getTestData()
cross_validation_k = 5
print('Using classic linear regression to evaluate...')
regression = LinearModel.LinRegression(X_train, y_train, X_test, y_test,
cross_validation_k)
accuracy, f1_score, lin_reg_y_prediction, lin_reg_cv_score = regression.evaluate(
)
print('Achieved accuracy of %s and f1 score of %s' % (accuracy, f1_score))
print('Using lasso linear regression to evaluate...')
lasso_reg = LinearModel.LassoRegression(X_train, y_train, X_test, y_test,
cross_validation_k)
accuracy, f1_score, lasso_reg_y_prediction, lasso_reg_cv_score = lasso_reg.evaluate(
alpha=0.5)
print('Achieved accuracy of %s and f1 score of %s' % (accuracy, f1_score))
print('Using logistic regression to evaluate...')
log_reg = LinearModel.LogisticRegression(X_train, y_train, X_test, y_test,
cross_validation_k)
accuracy, f1_score, log_reg_y_prediction, log_reg_cv_score = log_reg.evaluate(
def generate_embedding_model(text,
y,
batch_size=256,
epochs=100,
save=True,
dim=200,
val_split=0.2):
# Preprocessing
#MAX_SEQUENCE_LENGTH = len(max(text, key=lambda i: len(i))) + 1
MAX_SEQUENCE_LENGTH = 335
texts = [''.join(x) for x in text]
# finally, vectorize the text samples into a 2D integer tensor
tokenizer = Tokenizer()
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
word_index = tokenizer.word_index
print('Found %s unique tokens.' % len(word_index))
data = pad_sequences(sequences, maxlen=MAX_SEQUENCE_LENGTH)
labels = to_categorical(np.asarray(y))
print('Shape of data tensor:', data.shape)
print('Shape of label tensor:', labels.shape)
num_words = len(word_index) + 1
# split the data into a training set and a validation set
indices = np.arange(data.shape[0])
np.random.shuffle(indices)
data = data[indices]
labels = labels[indices]
num_validation_samples = int(val_split * data.shape[0])
x_train = data[:-num_validation_samples]
y_train = labels[:-num_validation_samples]
x_val = data[-num_validation_samples:]
y_val = labels[-num_validation_samples:]
emb = get_skipgram_embedding_matrix(text, epochs=1)
emb = np.expand_dims(emb, 1)
emb_train = emb[:-num_validation_samples]
emb_val = emb[-num_validation_samples:]
# Build model
MAX_SEQUENCE_LENGTH = len(max(text, key=lambda i: len(i))) + 1
# sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH,), dtype='int32',name="embedding_input")
#
# glove_embedding_layer = Embedding(num_words,
# dim,
# weights=[get_glove_embedding_matrix(word_index, dim)],
# input_length=MAX_SEQUENCE_LENGTH,
# trainable=False)(sequence_input)
#
# skipgram_embedding_layer = Embedding(num_words,
# dim,
# weights=[get_skipgram_embedding_matrix(texts, dim)],
# input_length=MAX_SEQUENCE_LENGTH,
# trainable=False)(sequence_input)
#
# # skipgram_embedding = Input(shape=(1,dim,),name="skipgram_input")
#
#
# own_embedding_layer = Embedding(num_words,
# dim,
# #embeddings_initializer=Constant(get_skipgram_embedding_matrix(text, epochs=1)),
# #weights=get_skipgram_embedding_matrix(text, epochs=1),
# input_length=MAX_SEQUENCE_LENGTH,
# trainable=True)(sequence_input)
#
# combined = keras.backend.stack([glove_embedding_layer, skipgram_embedding_layer, own_embedding_layer], axis=3)
#
# #x = Conv2D(128, 5, activation='relu')(combined)
# #x = MaxPooling2D(5)(x)
# #x = Conv2D(128, 5, activation='relu')(x)
# #x = MaxPooling2D(5)(x)
# #x = Conv2D(128, 5, activation='relu')(x)
# #x = GlobalMaxPooling2D()(x)
# #x = Dense(128, activation='relu')(x)
# x = DenseNet121(include_top=False, weights="imagenet", input_shape = (MAX_SEQUENCE_LENGTH, dim, 3))(combined)
# x = GlobalAveragePooling2D()(x)
# preds = Dense(3, activation='softmax')(x)
#
# model = Model(inputs=sequence_input, outputs=preds)
# model.compile(loss='categorical_crossentropy',
# optimizer='rmsprop',
# metrics=['acc'])
#
# model.summary()
# plot_model(model, to_file='model_combined.png')
#
# # Train model
# model.fit(x_train, y_train,
# batch_size=batch_size,
# epochs=epochs,
# validation_data=(x_val, y_val))
# Get glove and skipgram embedding matrices
glove = get_glove_embedding_matrix(word_index, dim) #TODO: anpassen
skipgram = get_skipgram_embedding_matrix(texts, dim) #TODO: anpassen
# Get Model
model = LinearModel(embedding_matrix_gl=glove,
embedding_matrix_sg=skipgram,
number_class=3)
if save:
model.save("data/sentqs_full.h5")
return model
def main(opt):
start_epoch = 0
acc_best = 0.
glob_step = 0
lr_now = opt.lr
# save options
log.save_options(opt, opt.ckpt)
tb_logdir = f'./exp/{opt.name}'
if os.path.exists(tb_logdir):
shutil.rmtree(tb_logdir)
writer = SummaryWriter(log_dir=f'./exp/{opt.name}')
exp_dir_ = dirname(opt.load)
# create model
print(">>> creating model")
# TODO: This is how to avoid weird data reshaping for non-3-channel inputs.
# Have ResNet model take in grayscale rather than RGB
# model.conv1 = torch.nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False)
if opt.arch == 'cnn':
model = ResNet(BasicBlock, [2, 2, 2, 2], num_classes=opt.num_classes)
else:
model = LinearModel()
model = model.cuda()
model.apply(weight_init)
print(">>> total params: {:.2f}M".format(
sum(p.numel() for p in model.parameters()) / 1000000.0))
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.Adam(model.parameters(), lr=opt.lr)
# load ckpt
if opt.load:
print(">>> loading ckpt from '{}'".format(opt.load))
ckpt = torch.load(opt.load)
start_epoch = ckpt['epoch']
acc_best = ckpt['acc']
glob_step = ckpt['step']
lr_now = ckpt['lr']
model.load_state_dict(ckpt['state_dict'])
optimizer.load_state_dict(ckpt['optimizer'])
print(">>> ckpt loaded (epoch: {} | acc: {})".format(
start_epoch, acc_best))
if opt.resume:
logger = log.Logger(os.path.join(opt.ckpt, 'log.txt'), resume=True)
else:
logger = log.Logger(os.path.join(opt.ckpt, 'log.txt'))
logger.set_names([
'epoch', 'lr', 'loss_train', 'err_train', 'acc_train', 'loss_test',
'err_test', 'acc_test'
])
transforms = [
ToTensor(),
]
train_datasets = []
for dataset_name in opt.train_datasets:
train_datasets.append(
ClassificationDataset(name=dataset_name,
num_kpts=opt.num_kpts,
transforms=transforms,
split='train',
arch=opt.arch,
gt=opt.gt))
train_dataset = ConcatDataset(train_datasets)
train_loader = DataLoader(train_dataset,
batch_size=opt.train_batch,
shuffle=True,
num_workers=opt.job)
split = 'test' if opt.test else 'valid'
test_dataset = ClassificationDataset(name=opt.test_dataset,
num_kpts=opt.num_kpts,
transforms=transforms,
split=split,
arch=opt.arch,
gt=opt.gt)
test_loader = DataLoader(test_dataset,
batch_size=opt.test_batch,
shuffle=False,
num_workers=opt.job)
subset_loaders = {}
for subset in test_dataset.create_subsets():
subset_loaders[subset.split] = DataLoader(subset,
batch_size=opt.test_batch,
shuffle=False,
num_workers=opt.job)
cudnn.benchmark = True
for epoch in range(start_epoch, opt.epochs):
torch.cuda.empty_cache()
print('==========================')
print('>>> epoch: {} | lr: {:.5f}'.format(epoch + 1, lr_now))
if not opt.test:
glob_step, lr_now, loss_train, err_train, acc_train = \
train(train_loader, model, criterion, optimizer,
num_kpts=opt.num_kpts, num_classes=opt.num_classes,
lr_init=opt.lr, lr_now=lr_now, glob_step=glob_step,
lr_decay=opt.lr_decay, gamma=opt.lr_gamma,
max_norm=opt.max_norm)
loss_test, err_test, acc_test, auc_test, prec_test = \
test(test_loader, model, criterion, num_kpts=opt.num_kpts,
num_classes=opt.num_classes, batch_size=opt.test_batch)
## Test subsets ##
subset_losses = {}
subset_errs = {}
subset_accs = {}
subset_aucs = {}
subset_precs = {}
subset_openpose = {}
subset_missing = {}
subset_grids = {}
if len(subset_loaders) > 0:
bar = Bar('>>>', fill='>', max=len(subset_loaders))
for key_idx, key in enumerate(subset_loaders):
loss_sub, err_sub, acc_sub, auc_sub, prec_sub = test(
subset_loaders[key],
model,
criterion,
num_kpts=opt.num_kpts,
num_classes=opt.num_classes,
batch_size=4,
log=False)
subset_losses[key] = loss_sub
subset_errs[key] = err_sub
subset_accs[key] = acc_sub
subset_aucs[key] = auc_sub
subset_precs[key] = prec_sub
sub_dataset = subset_loaders[key].dataset
if sub_dataset.gt_paths is not None:
gt_X = load_gt(sub_dataset.gt_paths)
subset_openpose[key] = mpjpe_2d_openpose(sub_dataset.X, gt_X)
subset_missing[key] = mean_missing_parts(sub_dataset.X)
else:
subset_openpose[key] = 0.
subset_missing[key] = 0.
sample_idxs = extract_tb_sample(subset_loaders[key],
model,
batch_size=opt.test_batch)
sample_X = sub_dataset.X[sample_idxs]
sample_img_paths = [sub_dataset.img_paths[x] for x in sample_idxs]
if opt.arch == 'cnn':
subset_grids[key] = create_grid(sample_X, sample_img_paths)
bar.suffix = f'({key_idx+1}/{len(subset_loaders)}) | {key}'
bar.next()
if len(subset_loaders) > 0:
bar.finish()
###################
if opt.test:
subset_accs['all'] = acc_test
subset_aucs['all'] = auc_test
subset_precs['all'] = prec_test
report_dict = {
'acc': subset_accs,
'auc': subset_aucs,
'prec': subset_precs
}
report_idx = 0
report_path = f'report/{opt.name}-{report_idx}.json'
while os.path.exists(f'report/{opt.name}-{report_idx}.json'):
report_idx += 1
report_path = f'report/{opt.name}-{report_idx}.json'
print(f'>>> Saving report to {report_path}...')
with open(report_path, 'w') as acc_f:
json.dump(report_dict, acc_f, indent=4)
print('>>> Exiting (test mode)...')
break
# update log file
logger.append([
epoch + 1, lr_now, loss_train, err_train, acc_train, loss_test,
err_test, acc_test
], [
'int', 'float', 'float', 'float', 'float', 'float', 'float',
'float'
])
# save ckpt
is_best = acc_test > acc_best
acc_best = max(acc_test, acc_best)
if is_best:
log.save_ckpt(
{
'epoch': epoch + 1,
'lr': lr_now,
'step': glob_step,
'acc': acc_best,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()
},
ckpt_path=opt.ckpt,
is_best=True)
else:
log.save_ckpt(
{
'epoch': epoch + 1,
'lr': lr_now,
'step': glob_step,
'acc': acc_best,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()
},
ckpt_path=opt.ckpt,
is_best=False)
writer.add_scalar('Loss/train', loss_train, epoch)
writer.add_scalar('Loss/test', loss_test, epoch)
writer.add_scalar('Error/train', err_train, epoch)
writer.add_scalar('Error/test', err_test, epoch)
writer.add_scalar('Accuracy/train', acc_train, epoch)
writer.add_scalar('Accuracy/test', acc_test, epoch)
for key in subset_losses:
writer.add_scalar(f'Loss/Subsets/{key}', subset_losses[key], epoch)
writer.add_scalar(f'Error/Subsets/{key}', subset_errs[key], epoch)
writer.add_scalar(f'Accuracy/Subsets/{key}', subset_accs[key],
epoch)
writer.add_scalar(f'OpenPose/Subsets/{key}', subset_openpose[key],
epoch)
writer.add_scalar(f'Missing/Subsets/{key}', subset_missing[key],
epoch)
if opt.arch == 'cnn':
writer.add_images(f'Subsets/{key}',
subset_grids[key],
epoch,
dataformats='NHWC')
logger.close()
writer.close()
def trainLinear(maxiter=20, wp=(6 * 5, 6 * 1), lamuda=0.00, printOut=True):
class SCADADataset(Dataset):
# +jf33N train together
def __init__(self, name):
filename = 'dataGW' + name
with open(filename, 'rb') as f:
self.dataH, self.dataT = pickle.load(f)
def __len__(self):
return self.dataH.shape[0]
def __getitem__(self, idx):
x = np.copy(self.dataH[idx, :])
x = torch.from_numpy(x).float()
y = np.copy(self.dataT[idx])
y = torch.from_numpy(y).float()
return x, y
windL, predL = wp
(inputD, outD) = (windL, predL)
batch_size = 512
lr = 2e-4
weight_decay = 0.0000
print(' lr: ', lr, ' weight_decay: ', weight_decay, ' windL: ', windL,
' predL: ', predL, ' batch_size: ', batch_size, ' inputD: ', inputD,
' outD: ', outD, ' lamuda:', lamuda)
epochs = maxiter
start_epoch = 0
loadModel = False
outf = r'C:\YANG Luoxiao\Model\WindSpeed'
model = LinearModel(inputD, outD).to(device)
optimizer = optim.Adam(list(model.parameters()),
lr=lr,
weight_decay=weight_decay)
scheduler = ReduceLROnPlateau(optimizer, 'min', patience=20, verbose=True)
minloss = 10
# if loadModel:
# checkpoint = torch.load('%s/%s%d.pth' % (outf, "LSTMMutiTS4Best", num)) # largeNew5 Large5
# model.load_state_dict(checkpoint['model'])
# # D.load_state_dict(checkpoint['D'])
# optimizer.load_state_dict(checkpoint['optimizer'])
# # optimizerD.load_state_dict(checkpoint['optimizerD'])
# start_epoch = num
scadaTrainDataset = SCADADataset(name='Train')
dataloader = torch.utils.data.DataLoader(scadaTrainDataset,
batch_size=batch_size,
shuffle=True,
num_workers=int(0))
scadaValDataset = SCADADataset(name='Val')
dataloaderVAl = torch.utils.data.DataLoader(scadaValDataset,
batch_size=5000,
shuffle=True,
num_workers=int(0))
lossTrain = np.zeros(([1, 1]))
lossVal = np.zeros(([1, 1]))
acc = np.zeros(([1, 1]))
for epoch in range(start_epoch, start_epoch + epochs):
model.train()
for i, (x, y) in enumerate(dataloader):
optimizer.zero_grad()
# y = y.to(torch.long)
x = x.to(device).view(x.shape[0], -1)
y = y.to(device=device, dtype=torch.int64).view(-1)
ypred = model(x)
# y=y.long()
# l1loss=l1Norm(model)
# loss=F.mse_loss(tgt_y* 25.55 + 0.4, tgtpred* 25.55 + 0.4)
loss = F.cross_entropy(ypred, y)
loss.backward()
lossTrain = np.vstack(
(lossTrain, loss.detach().cpu().numpy().reshape((-1, 1))))
optimizer.step()
model.eval()
c = 0
loss = 0
accucry = 0
with torch.no_grad():
for p, (x, y) in enumerate(dataloaderVAl):
# if p>10:
# break
c += 1
x = x.to(device).view(x.shape[0], -1)
y = y.to(device=device, dtype=torch.int64).view(-1)
ypred = model(x)
loss += F.cross_entropy(ypred, y)
predict = torch.argmax(ypred, dim=1)
accucry += torch.sum(predict == y)
# break
lengA = len(scadaValDataset)
accucry = accucry.cpu().numpy()
accucry = accucry / lengA
lossVal = np.vstack((lossVal, (loss / c).cpu().numpy().reshape(
(-1, 1))))
acc = np.vstack((acc, accucry.reshape((-1, 1))))
model.train()
#
# break
if printOut:
if (i) % 2000 == 0:
print('[%d/%d][%d/%d]\tLoss: %.4f\t ' %
(epoch, start_epoch + epochs, i, len(dataloader),
loss))
model.eval()
c = 0
loss = 0
accucry = 0
with torch.no_grad():
for l, (x, y) in enumerate(dataloaderVAl):
c += 1
x = x.to(device).view(x.shape[0], -1)
y = y.to(device=device, dtype=torch.int64).view(-1)
ypred = model(x)
loss += F.cross_entropy(ypred, y)
predict = torch.argmax(ypred, dim=1)
accucry += torch.sum(predict == y)
lengA = len(scadaValDataset)
accucry = accucry.cpu().numpy()
accucry = accucry / lengA
if printOut:
print('VAL loss= ', loss / c, ' VAL accucry ', accucry)
scheduler.step(loss / c)
if minloss > (loss / c):
state = {
'model': model.state_dict(),
'optimizer': optimizer.state_dict(),
'epoch': epoch
}
if lamuda == 0:
torch.save(state,
'%s/GWRLLinearWT%d.pth' % (outf, int(predL / 6)))
else:
torch.save(state,
'%s/RLlassoWT%d.pth' % (outf, int(predL / 6)))
minloss = loss / c
# minmapeloss=lossm/ c
if printOut:
print('bestaccucry: ', accucry)
return lossTrain[1:, :], lossVal[1:, :], acc[1:, :]
class Trainer:
def __init__(self,
checkpoint_name,
num_classes,
num_input_features,
max_epochs=100,
lr=1e-2,
weight_decay=5e-2):
self.checkpoint_name = checkpoint_name
self.checkpoint_dir = os.path.join(CHECKPOINT_DIR,
self.checkpoint_name)
if not os.path.exists(self.checkpoint_dir):
os.makedirs(self.checkpoint_dir)
self.max_epochs = max_epochs
self.epoch = 0
self.lr = lr
self.weight_decay = weight_decay
self.num_classes = num_classes
self.num_input_features = num_input_features
self.model = LinearModel(num_classes=self.num_classes,
num_input_features=self.num_input_features)
self.loss_fn = nn.CrossEntropyLoss()
self.optimizer = optim.Adam(self.model.parameters(),
lr=self.lr,
amsgrad=True,
weight_decay=weight_decay)
# self.log_dir = os.path.join(LOG_DIR, self.checkpoint_name)
self.log_writer = tensorboardX.SummaryWriter('logs/' +
self.checkpoint_name)
self.load_checkpoint('model.pt')
def train(self, train_dataset, test_dataset, batch_size, eval_batch_size):
train_data_loader = data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
drop_last=True)
test_data_loader = data.DataLoader(test_dataset,
batch_size=eval_batch_size,
shuffle=False,
drop_last=False)
start_epoch = self.epoch
print("Training...\n")
for epoch in range(start_epoch, self.max_epochs):
self.epoch += 1
self.train_step(train_data_loader)
train_acc = self.evaluate_step(train_data_loader)
test_acc = self.evaluate_step(test_data_loader)
self.log_writer.add_scalars('accuracy', {
'test': test_acc,
'train': train_acc
}, self.epoch)
if self.epoch % 20 == 0:
print("===== Epoch {} =====".format(self.epoch))
print('test-acc: {0}\ttrain acc: {1}'.format(
test_acc, train_acc))
def train_step(self, train_data_loader):
self.model.train()
epoch_losses = list()
for (features, labels) in train_data_loader:
# print(features.shape)
self.optimizer.zero_grad()
predictions = self.model(features)
loss = self.loss_fn(predictions, labels.long().view(-1))
loss.backward()
self.optimizer.step()
epoch_losses.append(loss.item())
self.save_checkpoint('model.pt')
self.log_writer.add_scalar('loss', np.mean(epoch_losses), self.epoch)
def evaluate_step(self, test_data_loader):
self.model.eval()
num_correct = 0
num_data = 0
with torch.no_grad():
for (features, labels) in test_data_loader:
predictons = self.model(features)
predictions = torch.argmax(
predictons,
dim=1) # take the argmax over the class dimension N x C
is_correct = torch.eq(predictions.view(-1),
labels.long().view(-1)).int()
num_correct += torch.sum(is_correct).item()
num_data += labels.size(0)
accuracy = num_correct / num_data
return accuracy
def save_checkpoint(self, filename):
checkpoint_filepath = os.path.join(self.checkpoint_dir, filename)
torch.save(
{
'epoch': self.epoch,
'model': self.model.state_dict(),
'optim': self.optimizer.state_dict()
}, checkpoint_filepath)
def load_checkpoint(self, filename):
checkpoint_filepath = os.path.join(self.checkpoint_dir, filename)
if os.path.exists(checkpoint_filepath):
checkpoint = torch.load(checkpoint_filepath)
self.epoch = checkpoint['epoch']
self.model.load_state_dict(checkpoint['model'])
self.optimizer.load_state_dict(checkpoint['optim'])
print("Loaded checkpoint")
else:
print("Checkpoint not found, continuing...")
def evaluate_model_on_train(title,
model_name,
preprocessing,
data,
results_df: pd.DataFrame,
model: LinearModel,
verbose=cfg.verbose,
visualize=True):
"""
Cross-validation, split train data frame to equally sized val and train data sets and evaluate R2 adjusted and RMSE
:param title: name of experiment to be saved in results data frame
:param model_name: name of linear model used in experiment
:param preprocessing: type of postprocessing, if a massive change is preformed please write down in short
what the postprocessing includes(like normal)
:param data: train data frame with SalePrice given
:param results_df: where to put the result of the experiment
:param model: model that implements the LinearModel interface
:param verbose: to print the results on console
:return:
"""
print(
"------------------ Training on train and CV on Train ------------------"
)
X, Y = data
if visualize:
X_train, X_val, Y_train, Y_val = split_data(X, Y)
model.model_fit(X_train, Y_train)
y_val_pred = model.predict(X_val)
plt.figure()
sns.residplot(y_val_pred, Y_val, lowess=True, color="b")
plt.xlabel("Fitted values")
plt.ylabel("Residuals")
plt.title(model_name)
plt.savefig(cfg.visualization_dir + "/Residuals_{}".format(model_name))
print("------------------ Evaluating on Train ------------------")
model.model_fit(X, Y)
train_rmse, train_R2_adjusted = model.model_eval(X, Y, False)
rmse_cv_score = np.sqrt(
np.abs(
cross_val_score(model.get_model(),
X,
Y,
cv=5,
scoring='neg_mean_squared_error')))
R2_cv_score = cross_val_score(model.get_model(), X, Y, cv=5, scoring='r2')
if verbose:
print("train: \n rmse: {}, R2_adj: {}".format(train_rmse,
train_R2_adjusted))
print("cross validation rmse score: {} (+/- {}".format(
rmse_cv_score.mean(),
rmse_cv_score.std() * 2))
print("cross validation r2 score: {} (+/- {}".format(
R2_cv_score.mean(),
R2_cv_score.std() * 2))
results = [
build_result_line(title, 'train', model_name, preprocessing,
train_rmse, train_R2_adjusted),
build_result_line(title, 'val', model_name, preprocessing,
rmse_cv_score.mean(), R2_cv_score.mean())
]
if title in results_df['title'].values:
print(
"Warning: Overwriting previous experiement due to colliding title")
user_input = over_write_or_exit_from_usr()
if user_input == 'e':
print("not saving results, existing....")
exit()
if user_input == 'd':
print("deleting previous results, existing....")
criteria = results_df['title'].values != title
results_df = results_df[criteria]
results_df.to_pickle(path=cfg.results_df)
results_df.to_csv(path_or_buf=cfg.results_path, index=False)
exit()
criteria = results_df['title'].values != title
results_df = results_df[criteria]
results_df = results_df.append(
pd.DataFrame(results,
columns=[
'title', 'dataset', 'model_name', 'preprocessing',
'rmse', 'R2_adjusted'
]))
results_df.to_pickle(path=cfg.results_df)
results_df.to_csv(path_or_buf=cfg.results_path, index=False)
def run_manual():
w = []
final_reward, actions, _ = computeReward(LinearModel(w), True)
print("Final reward = ", final_reward, task.summarize_actions(actions))
Y_data[1] = 100.0
Y_data[-5] = 100.0
Y_data = Y_data.reshape((-1,1))
X_test = 3.2*np.ones((1,1))
Y_test = true_function(X_test, noise=False)
num_train_points = X_data.shape[0]
tf.reset_default_graph()
x = tf.placeholder(dtype=tf.float32, shape=(None, 1))
y_true = tf.placeholder(dtype=tf.float32, shape=(None, 1))
model = LinearModel(x, y_true)
train_op = model.optimize
loss_op = model.error
param_op = model.params
gradient_op = model.gradients
hessian_op = model.hessians
init_op = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init_op)
for e in range(EPOCHS):
#encoding=utf-8
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from utils import accuracy, makedata
from model import LinearModel, RandomTree, HufTree
import time
chose_features, chose_labels, chose_weight_dict, idx_train, idx_val, idx_test = makedata(
)
l_model = LinearModel(chose_features.shape[1], 7)
r_model = RandomTree(chose_features.shape[1], 8, 7, chose_weight_dict, 0.2)
h_model = HufTree(chose_features.shape[1], 8, 7, chose_weight_dict, 0.2)
optimer1 = optim.Adam(l_model.parameters(), lr=0.01, weight_decay=1e-5)
optimer2 = optim.Adam(r_model.parameters(), lr=0.01, weight_decay=1e-5)
optimer3 = optim.Adam(h_model.parameters(), lr=0.01, weight_decay=1e-5)
def train(epoch):
t = time.time()
optimer1.zero_grad()
optimer2.zero_grad()
optimer3.zero_grad()
output1 = l_model(chose_features)
output2 = r_model(chose_features)
output3 = h_model(chose_features)
loss_train1 = F.nll_loss(output1[idx_train], chose_labels[idx_train])
parser.add_argument('--visualize',
'-v',
action='store_true',
help='Visualize training progress')
parser.add_argument(
'--batchsize',
'-b',
default=1000,
type=int,
help='Batch size for training the network (default: %(default)s)')
args = parser.parse_args()
np.random.seed(args.seed)
loss = L2Loss()
model = LinearModel(widths=[2, 12, 32, 12, 2], lr=0.01, loss=loss)
optimizer = None
if args.optimizer == 'ibfgs':
optimizer = InverseBFGS(nparams=model.nparams, gamma=0.0001, eta=0.9)
elif args.optimizer == 'bfgs':
optimizer = BFGS(nparams=model.nparams, gamma=0.0001, eta=0.9)
elif args.optimizer == 'armijo':
optimizer = DescentMethod(nparams=model.nparams, beta=1 / 2, gamma=0.0001)
elif args.optimizer == 'bbv1' or args.optimizer == 'barzilaiborweinv1':
optimizer = BarzilaiBorwein(nparams=model.nparams,
beta=1 / 2,
gamma=0.0001,
strategy='v1')
elif args.optimizer == 'bbv2' or args.optimizer == 'barzilaiborweinv2':
optimizer = BarzilaiBorwein(nparams=model.nparams,
class DQNAgent():
"""Implementation of DQN"""
def __init__(self, state_size, action_size, seed, opts={}):
"""Initialise the agent
Params
======
state_size (int): dimension of each state
action_size (int): dimension of each action
seed (int): Random seed
opts (dict): optional settings
BUFFER_SIZE (long): Max size for replay buffer
BATCH_SIZE (int): Sample size of experiences from replay buffer
GAMMA (float): discount factor
TAU (float): soft update of target parameters
LR (float): optimizer learning rate
UPDATE_EVERY (int): how ofter to update the network
"""
self.state_size = state_size
self.action_size = action_size
self.seed = random.seed(seed)
self.local_network = LinearModel(state_size, action_size, seed).to(device)
self.fixed_network = LinearModel(state_size, action_size, seed).to(device)
# Overwrite the default parameters
self.buffer_size = opts['BUFFER_SIZE'] if 'BUFFER_SIZE' in opts else BUFFER_SIZE
self.batch_size = opts['BATCH_SIZE'] if 'BATCH_SIZE' in opts else BATCH_SIZE
self.gamma = opts['GAMMA'] if 'GAMMA' in opts else GAMMA
self.tau = opts['TAU'] if 'TAU' in opts else TAU
self.lr = opts['LR'] if 'LR' in opts else LR
self.update_every = opts['UPDATE_EVERY'] if 'UPDATE_EVERY' in opts else UPDATE_EVERY
self.optim = optim.Adam(self.local_network.parameters(), lr=self.lr)
# Initialize replay buffer
self.memory = ReplayBuffer(self.buffer_size, self.batch_size, seed)
# Initialize time step (for updating every UPDATE_EVERY steps)
self.t_step = 0
self.history = defaultdict(list)
def act(self, state, eps):
"""Returns the action for specified state
Params
======
state (array_like): environment state
eps (float): epsilon, to use in greedy-policy
"""
if random.random() < eps:
return random.choice(range(self.action_size))
else:
# convert the state to tensor
state = torch.from_numpy(state).float().unsqueeze(0).to(device)
# change network into evaluation mode with no gradients
self.local_network.eval()
with torch.no_grad():
action_values = self.local_network(state)
# change network back to training mode
self.local_network.train()
return np.argmax(action_values.cpu().data.numpy())
def step(self, state, action, reward, next_state, done):
"""Collects experience and learns from experience
Params
======
state (array_like): environment state (S)
action (int): action taken on state (A)
reward (float): reward (R) received by taking action A in state S
next_state (array_like): environment state (S') received after taking action A in state S
done (boolean): whether the episode ended after taking action A in state S
"""
self.memory.add(state, action, reward, next_state, done)
self.t_step += 1
if self.t_step % self.update_every == 0:
if len(self.memory) > self.batch_size:
experiences = self.memory.sample()
self.learn(experiences, self.gamma)
def learn(self, experiences, gamma):
"""Use experience to learn from it
Params
======
experiences (Tuple[torch.Tensor]): tuple of (s, a, r, s', done) tuples
gamma (float): discount factor
"""
# logger.debug('learn gamma: {}'.format(gamma))
states, actions, rewards, next_states, dones = experiences
Q_next = self.fixed_network(next_states).detach().max(1)[0].unsqueeze(1)
Q_target = rewards + (gamma * Q_next * (1 - dones))
Q_estimates = self.local_network(states).gather(1, actions)
loss = F.mse_loss(Q_estimates, Q_target)
self.history['loss'].append(loss.item())
# logger.debug('Loss: {}'.format(loss.item()))
self.optim.zero_grad()
loss.backward()
self.optim.step()
# Update fixed network
self.update_fixed_network(self.local_network, self.fixed_network, self.tau)
def update_fixed_network(self, local_model, target_model, tau):
"""Updates fixed target network weights using following:
target = tau * target_model weights + (1 - tau) * local_model weights
Params
======
local_model (Pytorch model): source model to copy weights from
target_model (Pytorch model): target model to copy weights to
tau (float): decide how much weight to apply when updating weights
"""
for target_weights, local_weights in zip(target_model.parameters(), local_model.parameters()):
target_weights.data.copy_(tau * target_weights + (1 - tau) * local_weights)
def save(self, filename):
"""Save local model parameters
Params
======
filename (string): filename
"""
torch.save(self.local_network.state_dict(), filename)
def main():
try:
parser = parse.parseSB(__version__)
options, args = parser.parse_args()
if len(args) < 1 or len(args) > 1:
parser.error("incorrect number of arguments (`--help` for help).")
if options.test_only and not options.model_file:
parser.error("option -m is required for --test-only.")
if options.test_only and options.test_file:
parser.error("options --test-only and -t are mutually exclusive.")
verbose = options.verbose
data_file = args[0]
dtrain = MemoryDataset.load(data_file, verbose = verbose)
if not options.test_only:
if verbose > 0:
print("---------")
print("Training:")
print("---------")
if len(dtrain.classes) > 2:
model = GeneralizedLinearModel(dtrain.dim,len(dtrain.classes),
biasterm = options.biasterm)
else:
model = LinearModel(dtrain.dim,
biasterm = options.biasterm)
trainer = create_trainer(options)
if isinstance(trainer, (OVA,MaxentSGD,AveragedPerceptron)):
if not isinstance(model, GeneralizedLinearModel):
raise ValueError("Multi-class classifiers "\
"require > 2 classes. ")
else:
if isinstance(model, GeneralizedLinearModel):
raise ValueError("%s cannot be used "\
"for multi-class problems." % str(trainer))
trainer.train(model,dtrain,verbose = verbose,
shuffle = options.shuffle)
if options.computetrainerror:
test_model(model, dtrain, text="Training error")
if options.model_file:
f = open(options.model_file, 'w+')
try:
pickle.dump(model,f)
finally:
f.close()
if options.test_file:
dtest = MemoryDataset.load(options.test_file,
verbose = verbose)
if options.prediction_file:
write_predictions(model, dtest, options.prediction_file)
else:
test_model(model, dtest)
else:
model = None
f = open(options.model_file, 'r')
try:
model = pickle.load(f)
finally:
f.close()
if not model:
raise Exception("cannot deserialize "\
"model in '%s'. " % options.model_file)
if options.prediction_file:
write_predictions(model, dtrain, options.prediction_file)
else:
test_model(model, dtrain)
except Exception, exc:
print "[ERROR] ", exc
def trainLinear(maxiter=20,
wp=(6 * 5, 6 * 1),
lamuda=0.00,
printOut=True,
k0=10,
t=4):
class SCADADataset(Dataset):
# +jf33N train together
def __init__(self, name):
filename = 'dataTW10' + name
with open(filename, 'rb') as f:
self.dataH, self.dataT = pickle.load(f)
kMeans = KMeans(k0).fit(self.dataH)
self.labels = kMeans.labels_
def __len__(self):
return self.dataH.shape[0]
def __getitem__(self, idx):
x = np.copy(self.dataH[idx, :])
x = torch.from_numpy(x).float()
lb = self.labels[idx]
y = np.copy(self.dataT[idx])
# y = torch.from_numpy(y).float()
return x, y, lb
windL, predL = wp
(inputD, outD) = (windL, predL)
batch_size = 1024
lr = 2e-4
weight_decay = 0.0000
print(' lr: ', lr, ' weight_decay: ', weight_decay, ' windL: ', windL,
' predL: ', predL, ' batch_size: ', batch_size, ' inputD: ', inputD,
' outD: ', outD, ' lamuda:', lamuda)
epochs = maxiter
start_epoch = 0
loadModel = False
outf = r'C:\YANG Luoxiao\Model\WindSpeed'
model = LinearModel(inputD, outD).to(device)
optimizer = optim.Adam(list(model.parameters()),
lr=lr,
weight_decay=weight_decay)
scheduler = ReduceLROnPlateau(optimizer, 'min', patience=20, verbose=True)
minloss = 10
# if loadModel:
# checkpoint = torch.load('%s/%s%d.pth' % (outf, "LSTMMutiTS4Best", num)) # largeNew5 Large5
# model.load_state_dict(checkpoint['model'])
# # D.load_state_dict(checkpoint['D'])
# optimizer.load_state_dict(checkpoint['optimizer'])
# # optimizerD.load_state_dict(checkpoint['optimizerD'])
# start_epoch = num
scadaTrainDataset = SCADADataset(name='Train')
dataloader = torch.utils.data.DataLoader(scadaTrainDataset,
batch_size=batch_size,
shuffle=True,
num_workers=int(0))
scadaValDataset = SCADADataset(name='Val')
dataloaderVAl = torch.utils.data.DataLoader(scadaValDataset,
batch_size=1024,
shuffle=True,
num_workers=int(0))
lossTrain = np.zeros(([1, 1]))
lossVal = np.zeros(([1, 1]))
acc = np.zeros(([1, 1]))
for epoch in range(start_epoch, start_epoch + epochs):
model.train()
ckD = {}
for kk in range(k0):
ckD[kk] = 0
lossTotal = 0
for i, (x, y, lb) in enumerate(dataloader):
loss1 = 0
loss2 = 0
loss3 = 0
optimizer.zero_grad()
# y = y.to(torch.long)
x = x.to(device).view(x.shape[0], -1)
y = y.to(device=device, dtype=torch.int64).view(-1)
gh = model(x)
for kk in range(k0):
ghk = gh[lb == kk, :]
if ghk.shape[0] == 0:
ckD[kk] = torch.zeros((windL)).to(device)
# k=k0-1
continue
ckD[kk] = torch.sum(ghk, dim=0) / (ghk.shape[0]) / (i + 1)
loss1 += F.mse_loss(ghk, ckD[kk])
for kkk in range(k0):
for kkkk in range(kkk, k0):
loss2 += torch.sum((ckD[kkk] - ckD[kkkk])**2)
for tt in range(t):
ght = gh[y == tt, :]
if ght.shape[0] < 2:
continue
loss3 += torch.sum((ght[0, :] - ght[1, :])**2)
# y=y.long()
# l1loss=l1Norm(model)
loss1 /= k0
loss2 /= (k0 * (k0 + 1) / 2)
loss3 /= t
# loss=F.mse_loss(tgt_y* 25.55 + 0.4, tgtpred* 25.55 + 0.4)
loss = loss1 + loss2 + loss3
loss.backward()
lossTrain = np.vstack(
(lossTrain, loss.detach().cpu().numpy().reshape((-1, 1))))
optimizer.step()
model.eval()
trans = np.zeros((k0, t))
gh = model(
torch.from_numpy(scadaTrainDataset.dataH).float().to(
device)).detach().cpu().numpy()
kMeans = KMeans(k0).fit(gh)
scadaTrainDataset.labels = kMeans.labels_
for b in range(k0):
tk0 = scadaTrainDataset.dataT[scadaTrainDataset.labels == b]
for bb in range(t):
trans[b, bb] = np.sum(tk0 == bb) / len(tk0)
# print(trans)
classP = np.argmax(trans, axis=1)
c = 0
accucry = 0
with torch.no_grad():
for p, (x, y, lb) in enumerate(dataloaderVAl):
# if p>10:
# break
c += 1
x = x.numpy()
labx = kMeans.predict(x)
pry = classP[labx]
y = y.view(-1).numpy()
# predict=torch.argmax(ypred,dim=1)
accucry += np.sum(pry == y)
lengA = len(scadaValDataset)
# accucry = accucry.cpu().numpy()
accucry = accucry / lengA
# lossVal = np.vstack((lossVal, (loss/c).cpu().numpy().reshape((-1, 1))))
acc = np.vstack((acc, accucry.reshape((-1, 1))))
model.train()
#
# break
if printOut:
if (i) % 20 == 0:
print('[%d/%d][%d/%d]\tLoss: %.4f\t ' %
(epoch, start_epoch + epochs, i, len(dataloader),
loss))
# model.eval()
# trans = np.zeros((k0, t))
# gh = model(torch.from_numpy(scadaTrainDataset.dataH).float().to(device)).detach().cpu().numpy()
# kMeans = KMeans(k0).fit(gh)
# scadaTrainDataset.labels = kMeans.labels_
# for b in range(k0):
# tk0 = scadaTrainDataset.dataT[scadaTrainDataset.labels == b]
# for bb in range(t):
# trans[b, bb] = np.sum(tk0 == bb) / len(tk0)
# print(trans)
# classP=np.argmax(trans,axis=1)
# c=0
# loss = 0
# accucry=0
# with torch.no_grad():
# for l, (x,y,lb) in enumerate(dataloaderVAl):
# c += 1
# x = x.numpy()
# labx=kMeans.predict(x)
# pry=classP[labx]
# y = y.view(-1).numpy()
#
# # predict=torch.argmax(ypred,dim=1)
# accucry+=np.sum(pry==y)
# lengA=len(scadaValDataset)
# # accucry=accucry.cpu().numpy()
# accucry=accucry/lengA
# if printOut:
# print('VAL loss= ', loss / c, ' VAL accucry ', accucry)
# #
# scheduler.step(loss / c)
# if minloss > (loss / c):
# state = {'model': model.state_dict(),'optimizer': optimizer.state_dict(),
# 'epoch': epoch}
# if lamuda==0:
#
# torch.save(state, '%s/TW10RLLinearWT%d.pth' % (outf, int(predL / 6)))
# else:
#
# torch.save(state, '%s/RLlassoWT%d.pth' % (outf, int(predL / 6)))
# minloss = loss / c
# # minmapeloss=lossm/ c
# if printOut:
# print('bestaccucry: ', accucry)
# k0=k
# print(k)
return lossTrain[1:, :], lossVal[1:, :], acc[1:, :]
def main():
parser = argparse.ArgumentParser(description='D2L Linear Regression')
parser.add_argument('--run_mode',
type=str,
nargs='?',
default='mxnet',
help='input run_mode. "raw" or "mxnet"')
args = parser.parse_args()
run_mode = args.run_mode
num_inputs = 2
num_examples = 1000
batch_size = 10
lr = 0.03 # Learning rate
num_epochs = 10 # Number of iterations
print(f'run {run_mode} code ...')
if run_mode == 'raw':
data_loader = Dataloader(TRUE_W, TRUE_B, num_inputs, num_examples,
batch_size)
features, labels = data_loader.get_data()
model = LinearModel(num_inputs, lr, batch_size)
for epoch in range(num_epochs):
# Assuming the number of examples can be divided by the batch size, all
# the examples in the training data set are used once in one epoch
# iteration. The features and tags of mini-batch examples are given by X
# and y respectively
for X, y in data_loader.data_iter():
with autograd.record():
# Minibatch loss in X and y
l = model.squared_loss(model.linreg(X), y)
l.backward() # Compute gradient on l with respect to [w,b]
model.sgd()
# sgd([w, b], lr, batch_size) # Update parameters using their gradient
train_l = model.squared_loss(model.linreg(features), labels)
print('epoch %d, loss %f' % (epoch + 1, train_l.mean().asnumpy()))
else:
data_loader = MxDataLoader(TRUE_W, TRUE_B, num_inputs, num_examples,
batch_size)
features, labels = data_loader.get_data()
model = MxLinearModel(lr)
for epoch in range(num_epochs):
for X, y in data_loader.data_iter:
with autograd.record():
l = model.loss(model.net(X), y)
l.backward()
model.trainer.step(batch_size)
l = model.loss(model.net(features), labels)
print('epoch %d, loss: %f' % (epoch, l.mean().asnumpy()))
model.print_result(TRUE_W, TRUE_B)
