def __init__(self, value_matrix, target_matrix, mode='msl'):
"""
:param value_matrix: N lists with each D dim features
:param target_matrix: N lists with each M dim targets
:param mode: msl or mtl
msl: multi-single-lasso
mtl: multi-task-lasso
"""
self._logger = Logger()
self._logger.info(module='factormodel',
file='multtask.py',
content="Building mult-tasks fitting.")
assert (len(value_matrix) == len(target_matrix))
self._A = value_matrix
self._B = target_matrix
self._lars_regressor_list = []
# construct lars regression model list
assert (len(self._A) == len(self._B))
self._A_cov = Covariance(self._A)
self._B_cov = Covariance(self._B)
self._A_mean = self._A_cov.mean_matrix
self._A_norm = self._A_cov.norm_matrix
self._A_std = self._A_cov.std_matrix
self._A_normalized = self._A_cov.normalized_matrix
self._A_instance_list = self._A_normalized.T.tolist()
self._B_mean = self._B_cov.mean_matrix
self._B_norm = self._B_cov.norm_matrix
self._B_std = self._B_cov.std_matrix
self._B_normalized = self._B_cov.normalized_matrix
self._beta_matrix_decay = None
self._logger.info(
module='factormodel',
file='multtask.py',
content="Gram construction complete, now doing model fitting.")
if mode == 'msl':
self._Beta_msl = []
for i, target_vec in enumerate(self._B_normalized.tolist()):
lars_regressor = LarsRegression([2, 3], 10, 5)
lars_regressor.filling(self._A_instance_list, target_vec)
lars_regressor.fitting_with_cross_validation()
self._Beta_msl.append(lars_regressor.predict_coef)
# print " the task %s is complete." % str(i)
self._beta_matrix_decay = np.array(self._Beta_msl).T
elif mode == 'mtl':
""" (1 / (2 * n_samples)) * ||Y - XW||^Fro_2 + alpha * ||W||_21
||W||_21 = \sum_i \sqrt{\sum_j w_{ij}^2}
"""
self._beta_matrix_decay = MultiTaskLassoCV(cv=2).fit(
self._A_normalized.T, self._B_normalized.T).coef_
self._beta_matrix_decay = np.array(self._beta_matrix_decay).T
self._logger.info(module='factormodel',
file='multtask.py',
content="The multi-tasks fitting complete.")
self._beta_matrix = np.multiply(self._beta_matrix_decay,
(1 / self._A_norm).dot(self._B_norm.T))
self._delta_matrix = -self._A_mean.T.dot(
self._beta_matrix) + self._B_mean.T
self._cov_matrix = self._beta_matrix.T.dot(
self._A_cov.empirical_covariance).dot(self._beta_matrix)
self._cov_matrix_lowrank = None
import os
import time
from lxml import etree
import requests
import base64
import hashlib
#from PIL import Image
import re
from util import Logger as myLogger
from config import myConfig
log = myLogger.Logger()
def getCookiesFromSession(session):
cookies = session.cookies.get_dict()
return cookies
def getCkFromCookies(session):
cookies = getCookiesFromSession(session)
ck = cookies.get('ck')
if (ck is None):
log.error("No ck found in cookies", cookies)
raise Exception('No ck found in cookies')
return ck
def loadCookies():
cookies = {}
def train_baselines():
train_data, val_data = get_dataloader(96)
for model, batch in zip(models, batch_size):
name = str(model).split()[1]
print('*****Start Training {} with batch size {}******'.format(name, batch))
print(' epoch iter rate | smooth_loss | train_loss (acc) | valid_loss (acc) | total_train_loss\n')
logger = Logger('/mnt/home/dunan/Learn/Kaggle/planet_amazon/log/full_data_{}_freeze'.format(name), name)
# load pre-trained model on train-37479
net = model(pretrained=True)
net = nn.DataParallel(net.cuda())
# load_net(net, name)
optimizer = get_optimizer(net.module, lr=.1, pretrained=True, resnet=True if 'resnet' in name else False)
# optimizer = optim.SGD(lr=.005, momentum=0.9, params=net.parameters(), weight_decay=5e-4)
train_data.batch_size = batch
val_data.batch_size = batch
num_epoches = 60
print_every_iter = 20
epoch_test = 1
smooth_loss = 0.0
train_loss = np.nan
train_acc = np.nan
best_test_loss = np.inf
t = time.time()
for epoch in range(num_epoches): # loop over the dataset multiple times
# train loss averaged every epoch
total_epoch_loss = 0.0
freeze_lr_schedule(epoch, optimizer, base_lr=0.1)
rate = get_learning_rate(optimizer)[0] # check
sum_smooth_loss = 0.0
total_sum = 0
sum = 0
net.cuda().train()
num_its = len(train_data)
for it, (images, labels, indices) in enumerate(train_data, 0):
logits = net(Variable(images.cuda()))
probs = F.sigmoid(logits)
loss = multi_criterion(logits, labels.cuda())
optimizer.zero_grad()
loss.backward()
optimizer.step()
# additional metrics
sum_smooth_loss += loss.data[0]
total_epoch_loss += loss.data[0]
sum += 1
total_sum += 1
# print statistics
if it % print_every_iter == print_every_iter-1:
smooth_loss = sum_smooth_loss/sum
sum_smooth_loss = 0.0
sum = 0
train_acc = multi_f_measure(probs.data, labels.cuda())
train_loss = loss.data[0]
print('\r{} {} {} | {} | {} {} | ... '.
format(epoch + it/num_its, it + 1, rate, smooth_loss, train_loss, train_acc),
)
total_epoch_loss = total_epoch_loss / total_sum
if epoch % epoch_test == epoch_test-1 or epoch == num_epoches-1:
net.cuda().eval()
test_loss, test_acc = evaluate(net, val_data)
print('\r')
print('{} {} {} | {} | {} {} | {} {} | {}'.
format(epoch + 1, it + 1, rate, smooth_loss, train_loss, train_acc, test_loss, test_acc,
total_epoch_loss))
# save if the current loss is better
if test_loss < best_test_loss:
print('save {} {}'.format(test_loss, best_test_loss))
torch.save(net.state_dict(), '/mnt/home/dunan/Learn/Kaggle/planet_amazon/model/full_data_{}_freeze.pth'.format(name))
best_test_loss = test_loss
logger.add_record('train_loss', total_epoch_loss)
logger.add_record('evaluation_loss', test_loss)
logger.add_record('f2_score', test_acc)
logger.save()
logger.save_plot()
logger.save_time(start_time=t, end_time=time.time())
def main():
# parser = argparse.ArgumentParser(description='Hyperparams')
# parser.add_argument('--arch', nargs='?', type=str, default='resnet50')
# parser.add_argument('--img_size', nargs='?', type=int, default=640,
# help='Height of the input image')
# parser.add_argument('--n_epoch', nargs='?', type=int, default=600,
# help='# of the epochs')
# parser.add_argument('--schedule', type=int, nargs='+', default=[200, 400],
# help='Decrease learning rate at these epochs.')
# parser.add_argument('--batch_size', nargs='?', type=int, default=1,
# help='Batch Size')
# parser.add_argument('--lr', nargs='?', type=float, default=1e-3,
# help='Learning Rate')
# parser.add_argument('--resume', nargs='?', type=str, default=None,
# help='Path to previous saved model to restart from')
# parser.add_argument('--checkpoint', default='', type=str, metavar='PATH',
# help='path to save checkpoint (default: checkpoint)')
# args = parser.parse_args()
# lr = args.lr
# schedule = args.schedule
# batch_size = args.batch_size
# n_epoch = args.n_epoch
# image_size = args.img_size
# resume = args.resume
# checkpoint_path = args.checkpoint
# arch = args.arch
lr = 1e-3
schedule = [200, 400]
batch_size = 16
# batch_size = 1
n_epoch = 100
image_size = 640
checkpoint_path = ''
# arch = 'resnet50'
arch = 'mobilenetV2'
resume = "checkpoints/ReCTS_%s_bs_%d_ep_%d" % (arch, batch_size, 5)
# resume = None
if checkpoint_path == '':
checkpoint_path = "checkpoints/ReCTS_%s_bs_%d_ep_%d" % (
arch, batch_size, n_epoch)
print('checkpoint path: %s' % checkpoint_path)
print('init lr: %.8f' % lr)
print('schedule: ', schedule)
sys.stdout.flush()
if not os.path.isdir(checkpoint_path):
os.makedirs(checkpoint_path)
kernel_num = 7
min_scale = 0.4
start_epoch = 0
data_loader = ReCTSDataLoader(
need_transform=True,
img_size=image_size,
kernel_num=kernel_num,
min_scale=min_scale,
train_data_dir='../ocr_data/ReCTS/img/',
train_gt_dir='../ocr_data/ReCTS/gt/'
# train_data_dir='/kaggle/input/rects-ocr/img/',
# train_gt_dir='/kaggle/input/rects-ocr/gt/'
)
ctw_root_dir = 'data/'
train_loader = torch.utils.data.DataLoader(data_loader,
batch_size=batch_size,
shuffle=True,
num_workers=3,
drop_last=True,
pin_memory=True)
if arch == "resnet50":
model = models.resnet50(pretrained=False, num_classes=kernel_num)
elif arch == "resnet101":
model = models.resnet101(pretrained=False, num_classes=kernel_num)
elif arch == "resnet152":
model = models.resnet152(pretrained=False, num_classes=kernel_num)
elif arch == "mobilenetV2":
model = PSENet(backbone="mobilenetv2",
pretrained=False,
result_num=kernel_num,
scale=1)
if torch.cuda.is_available():
model = torch.nn.DataParallel(model).cuda()
device = 'cuda'
else:
model = torch.nn.DataParallel(model)
device = 'cpu'
optimizer = torch.optim.SGD(model.parameters(),
lr=lr,
momentum=0.99,
weight_decay=5e-4)
title = 'ReCTS'
if resume:
print('Resuming from checkpoint.')
checkpoint_file_path = os.path.join(resume, "checkpoint.pth.tar")
assert os.path.isfile(
checkpoint_file_path
), 'Error: no checkpoint directory: %s found!' % checkpoint_file_path
checkpoint = torch.load(checkpoint_file_path,
map_location=torch.device(device))
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
shutil.copy(os.path.join(resume, 'log.txt'),
os.path.join(checkpoint_path, 'log.txt'))
logger = Logger(os.path.join(checkpoint_path, 'log.txt'),
title=title,
resume=True)
else:
print('Training from scratch.')
logger = Logger(os.path.join(checkpoint_path, 'log.txt'), title=title)
logger.set_names(
['Learning Rate', 'Train Loss', 'Train Acc.', 'Train IOU.'])
for epoch in range(start_epoch, n_epoch):
lr = adjust_learning_rate(schedule, lr, optimizer, epoch)
print('\nEpoch: [%d | %d] LR: %f' %
(epoch + 1, n_epoch, optimizer.param_groups[0]['lr']))
stat(model, (3, image_size, image_size))
train_loss, train_te_acc, train_ke_acc, train_te_iou, train_ke_iou = train(
train_loader, model, dice_loss, optimizer, epoch, lr,
checkpoint_path)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'lr': lr,
'optimizer': optimizer.state_dict(),
},
checkpoint=checkpoint_path)
logger.append([
optimizer.param_groups[0]['lr'], train_loss, train_te_acc,
train_te_iou
])
logger.close()
default="faceswap",
type=str,
help='Experiment tag')
parser.add_argument('--name', type=str, default='UMDFaces')
parser.add_argument('--num_img', type=int, default=300)
parser.add_argument('--clear_cache', action='store_true')
parser.add_argument('--preset', type=str, default='gan')
parser.add_argument('--set',
type=str,
default=None,
nargs=argparse.REMAINDER)
args = parser.parse_args()
cfg = get_config(args, now, src_dir=os.path.join(os.getcwd(), '../'))
print('>> Loading Logger...')
logger = Logger(cfg, None)
class_name = args.name.replace('-', '_')
imdb = eval(class_name)(cfg, args.name, logger=logger)
dset = DatasetSyn(cfg, imdb, 'train', 'fake')
# dset.swap_style = ['seamless']
dset.swap_style = {'warp': 0.0, 'smoothwarp': 1.0, 'seamless': 0.0}
check_path = os.path.join(cfg.test_path, 'check_faceswap', args.name)
os.makedirs(check_path, exist_ok=True)
import cv2
li = list(range(len(imdb.imgpath)))
import random
# print('>> Shuffling...')
# random.shuffle(li)
class IAAAClient(object):
""" IAAA 统一认证类
Attibutes:
class:
AppID str PKURunner 在 iaaa 下的 AppID
AppSecret str PKURunner 在 iaaa 下的 SecretKey
Cache_AccessToken str accesstoken 缓存 json 文件名
Token_Expired int token 过期秒数 （此处自定义为 2h）
logger Logger 日志类实例
instance:
studentID str iaaa 认证账号/学号
password str iaaa 认证密码
headers dict 基础请求头
"""
AppID = "PKU_Runner"
AppSecret = "7696baa1fa4ed9679441764a271e556e" # 或者说 salt
Cache_AccessToken = "PKURunner_AccessToken.json"
Token_Expired = 7200 # token 缓存 2 小时
logger = Logger("PKURunner.IAAA")
def __init__(self, studentID, password):
self.studentID = studentID
self.password = password
@property
def headers(self):
return {
"User-Agent": "Dalvik/2.1.0 (Linux; U; Android 8.0.0; MI 5 MIUI/V10.0.1.0.OAACNFH)",
}
def __request(self, method, url, raw=False, **kwargs):
""" 请求函数模板
Args:
method str 请求 method
url str 请求 url/path
raw bool 是否返回 Response 对象（默认 false），否则返回 json 数据
**kwargs 传给具体的 requests.request 函数
Returns:
respJson jsonData json 数据 if raw == False
resp Response 原始 Response 实例 if raw == True
Raises:
IAAARequestStatusError 请求状态码异常
IAAASuccessStateError success 状态为 false
"""
resp = requests.request(method, url, headers=self.headers, **kwargs)
if not resp.ok: # 校验 status_code
self.logger.error(dict(resp.headers))
raise IAAARequestStatusError("in resp.ok")
respJson = resp.json() # 校验 success 字段
if not respJson.get('success'):
self.logger.error(respJson)
raise IAAASuccessStateError("in resp.json")
return respJson if not raw else resp
def post(self, url, data={}, **kwargs):
""" requests.post 函数封装
"""
data["msgAbs"] = self.__get_msgAbs(data) # 添加鉴权字段
return self.__request('POST', url, data=data, **kwargs)
def __get_msgAbs(self, payload):
""" iaaa 鉴权算法
signature = MD5("&[key1]=[value1]&[key2]=[value2]..." + AppSecret) # key 按字典序排列
Args:
payload dict post 请求的 payload
Returns:
signature str 签名
"""
return MD5("&".join("=".join(item) for item in sorted(payload.items())) + self.AppSecret) # TreeMap 按 keys 升序遍历
def __login(self):
""" iaaa 登录 API
Returns:
token str token 字符串
"""
respJson = self.post("https://iaaa.pku.edu.cn/iaaa/svc/authen/login.do", {
"appId": self.AppID,
"userName": self.studentID,
"randCode": "", # 该字段必须要有
"password": self.password,
"smsCode": "", # 该字段必须要有
"otpCode": "", # 该字段必须要有
})
token = respJson.get('token')
json_dump(self.Cache_AccessToken, {
"token": token,
"expire_in": int(time.time()) + self.Token_Expired
})
return token
def get_token(self, refresh=False):
""" 如果 token 没有过期，则返回缓存 token ，否则重新登录
Args:
refresh bool 是否立即重新登录并刷新缓存（默认 false）
Returns:
token str token 字符串
"""
try:
if refresh:
token = self.__login()
else:
tokenCache = json_load(self.Cache_AccessToken)
if tokenCache["expire_in"] < time.time():
token = self.__login()
else:
token = tokenCache["token"]
except (FileNotFoundError, JSONDecodeError): # 无缓存文件或者文件为空
token = self.__login()
finally:
return token
def is_mobile_authen(self):
""" iaaa 校验是否为手机验证 API
（这个接口实际上不需要使用）
"""
respJson = self.post("https://iaaa.pku.edu.cn/iaaa/svc/authen/isMobileAuthen.do", {
"userName": self.studentID,
"appId": self.AppID,
})
self.logger.info(respJson)
"""
testmultdatagate
"""
from modeldata import *
import numpy as np
from util import Logger
from datetime import datetime
from datagate import (CSVLoader, DataHandler, DataGate, TripleGate)
logger = Logger('./log', 'DEBUG')
datahandler = DataHandler(CSVLoader('../../expdata/fund.csv'),
datetime(2011, 1, 1), datetime(2015, 12, 31))
symbol_list = datahandler.symbol_list
logger.info(module='datagate',
file='usetriplegate.py',
content="the num of valid symbols in the date range is %d." %
len(symbol_list))
fund_dg = DataGate(datahandler, symbol_list[0:2])
datahandler = DataHandler(CSVLoader('../../expdata/index.csv'),
datetime(2011, 1, 1), datetime(2015, 12, 31))
symbol_list = datahandler.symbol_list
logger.info(module='datagate',
file='usetriplegate.py',
content="the num of valid symbols in the date range is %d." %
len(symbol_list))
index_dg = DataGate(datahandler, symbol_list[0:2])
datahandler = DataHandler(CSVLoader('../../expdata/macro.csv'),
datetime(2011, 1, 1), datetime(2015, 12, 31))
def __init__(self, config, json_files, generate_dict=False,
mode=ModeType.EVAL):
"""
Another way to do this is keep the file handler. But when DataLoader's
num_worker bigger than 1, error will occur.
Args:
config:
"""
self.config = config
self.logger = Logger(config)
self._init_dict()
self.sample_index = []
self.sample_size = 0
self.model_mode = mode
self.files = json_files
for i, json_file in enumerate(json_files):
with open(json_file) as fin:
self.sample_index.append([i, 0])
while True:
json_str = fin.readline()
if not json_str:
self.sample_index.pop()
break
self.sample_size += 1
self.sample_index.append([i, fin.tell()])
def _insert_vocab(files, _mode=InsertVocabMode.ALL):
for _i, _json_file in enumerate(files):
with open(_json_file) as _fin:
for _json_str in _fin:
try:
self._insert_vocab(json.loads(_json_str), mode)
except:
print(_json_str)
# Dict can be generated using:
# json files or/and pretrained embedding
if generate_dict:
# Use train json files to generate dict
# If generate_dict_using_json_files is true, then all vocab in train
# will be used, else only part vocab will be used. e.g. label
vocab_json_files = config.data.train_json_files
mode = InsertVocabMode.LABEL
if self.config.data.generate_dict_using_json_files:
mode = InsertVocabMode.ALL
self.logger.info("Use dataset to generate dict.")
_insert_vocab(vocab_json_files, mode)
if self.config.data.generate_dict_using_all_json_files:
vocab_json_files += self.config.data.validate_json_files + \
self.config.data.test_json_files
_insert_vocab(vocab_json_files, InsertVocabMode.OTHER)
if self.config.data.generate_dict_using_pretrained_embedding:
self.logger.info("Use pretrained embedding to generate dict.")
self._load_pretrained_dict()
self._print_dict_info()
self._shrink_dict()
self.logger.info("Shrink dict over.")
self._print_dict_info(True)
self._save_dict()
self._clear_dict()
self._load_dict()
from typing import List
import os
import pandas as pd
from util import Logger
logger = Logger()
file_path = os.path.dirname(__file__)
def read_data_all(mode='prd') -> List[pd.DataFrame]:
"""
パイプライン実行に必要なデータの読み込み。mainからはこれだけ呼べば良くする。
mode='dev'だとtrainとtestで行数を制限して読み込みするので高速に動作確認できる
"""
data = [
read_train(mode),
read_test(mode),
read_specs(mode),
read_train_labels(mode),
read_submission()
]
logger.info_log('Reading data finished')
return data
def read_train(mode='prd') -> pd.DataFrame:
logger.info_log('Reading train.csv')
if mode == 'pkl':
return pd.read_pickle(
def main(args):
if args.checkpoint == '':
args.checkpoint = "checkpoints/ic15_%s_bs_%d_ep_%d"%(args.arch, args.batch_size, args.n_epoch)
if args.pretrain:
if 'synth' in args.pretrain:
args.checkpoint += "_pretrain_synth"
else:
args.checkpoint += "_pretrain_s1280"
print(('checkpoint path: %s'%args.checkpoint))
print(('init lr: %.8f'%args.lr))
print(('schedule: ', args.schedule))
sys.stdout.flush()
if not os.path.isdir(args.checkpoint):
os.makedirs(args.checkpoint)
writer=SummaryWriter(args.checkpoint)
kernel_num=18
start_epoch = 0
#####
#
#
#
#####
data_loader = IC15Loader(is_transform=True, img_size=args.img_size)
train_loader = torch.utils.data.DataLoader(
data_loader,
batch_size=args.batch_size,
shuffle=True,
num_workers=3,
drop_last=False,
pin_memory=True)
if args.arch == "resnet50":
model = models.resnet50(pretrained=True, num_classes=kernel_num)
elif args.arch == "resnet101":
model = models.resnet101(pretrained=True, num_classes=kernel_num)
elif args.arch == "resnet152":
model = models.resnet152(pretrained=True, num_classes=kernel_num)
elif args.arch == "vgg16":
model = models.vgg16(pretrained=False,num_classes=kernel_num)
model = torch.nn.DataParallel(model).cuda()
model.train()
if hasattr(model.module, 'optimizer'):
optimizer = model.module.optimizer
else:
# NOTE 这个地方的momentum对训练影响相当之大，使用0.99时训练crossentropy无法收敛.
optimizer = torch.optim.SGD(model.parameters(), lr=args.lr, momentum=0.9, weight_decay=5e-4)
title = 'icdar2015'
if args.pretrain:
print('Using pretrained model.')
assert os.path.isfile(args.pretrain), 'Error: no checkpoint directory found!'
checkpoint = torch.load(args.pretrain)
model.load_state_dict(checkpoint['state_dict'])
start_epoch = checkpoint['epoch']
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title)
logger.set_names(['Learning Rate', 'Train Loss','Train Acc.', 'Train IOU.'])
elif args.resume:
print('Resuming from checkpoint.')
assert os.path.isfile(args.resume), 'Error: no checkpoint directory found!'
checkpoint = torch.load(args.resume)
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
# optimizer.load_state_dict(checkpoint['optimizer'])
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title, resume=True)
else:
print('Training from scratch.')
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title)
logger.set_names(['Learning Rate', 'Train Loss','Train Acc.', 'Train IOU.'])
images_loss = {}
# data_plot = images_loss.values()
# import matplotlib.pyplot as plt
# plt.plot(data_plot)
# plt.ylabel('Loss plot')
# plt.show()
for epoch in range(start_epoch, args.n_epoch):
adjust_learning_rate(args, optimizer, epoch)
print(('\nEpoch: [%d | %d] LR: %f' % (epoch + 1, args.n_epoch, optimizer.param_groups[0]['lr'])))
train_loss, train_te_acc, train_te_iou = train(train_loader,images_loss, model, dice_loss, optimizer, epoch,writer)
if epoch %5 == 0 and epoch != 0:
save_checkpoint({
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'lr': args.lr,
'optimizer' : optimizer.state_dict(),
}, checkpoint=args.checkpoint,filename='checkpoint_%d.pth'%epoch)
logger.append([optimizer.param_groups[0]['lr'], train_loss, train_te_acc, train_te_iou])
logger.close()
writer.flush()
writer.close()
class JoyrunAuth(AuthBase):
""" Joyrun 请求鉴权类
Attibutes:
class:
logger Logger 日志类实例
Attributes:
params dict 请求参数
uid int 用户 ID
sid str 会话 ID
"""
logger = Logger("joyrun.auth")
def __init__(self, uid=0, sid=''):
self.params = {}
self.uid = uid
self.sid = sid
def reload(self, params={}, uid=0, sid=''):
""" 重新设置 params, uid, sid
Returns:
self JoyrunAuth 返回本身，马上用于鉴权
"""
self.params = params
if uid and sid:
self.uid = uid
self.sid = sid
return self
@classmethod
def __get_signature(cls, params, uid, sid, salt):
""" 两个通用 signature 的函数模板
"""
if not uid: # uid == 0 or ''
uid = sid = ''
preHashString = "{paramsString}{salt}{uid}{sid}".format(
paramsString="".join("".join((k, str(v)))
for k, v in sorted(params.items())),
salt=salt,
uid=str(uid),
sid=sid,
)
# cls.logger.debug(preHashString)
return MD5(preHashString).upper()
@classmethod
def get_signature_v1(cls, params, uid=0, sid=''):
""" signature V1
放在请求参数里
"""
return cls.__get_signature(params, uid, sid,
"1fd6e28fd158406995f77727b35bf20a")
@classmethod
def get_signature_v2(cls, params, uid=0, sid=''):
""" signature V2
放在请求头里
"""
return cls.__get_signature(params, uid, sid,
"0C077B1E70F5FDDE6F497C1315687F9C")
@classmethod
def login_url_sign(cls, path, dateline, strAry):
""" loginUrlSign 用于上传记录
描述了请求 url 的 path，请求时间，关键请求参数
Args:
path str 请求路径
dateline int 类似与时间戳
strAry list 关键请求参数
"""
return MD5("raowenyuan{path}joy{timestamp}the{keys}run".format(
path=path[:path.index('.')].lower()
if '.' in path else path.lower(),
timestamp=str(dateline),
keys="".join(map(str, strAry)).lower(),
)).lower()
@classmethod
def upload_signature(cls, path, dateline, lasttime, second, meter,
**kwargs):
""" 生成上传记录是的 sign 字段，对 loginUrlSign 的封装
Args:
path str 请求路径
dateline int 类似于时间戳
lasttime int 结束时间
second int 跑步时间
meter int 跑步距离
**kwargs 其他不需要的记录信息
"""
return cls.login_url_sign(path, dateline, [lasttime, second, meter])
def __call__(self, r):
params = self.params.copy()
if r.method == 'POST' and r.path_url.lstrip('/') == "po.aspx":
params["sign"] = self.upload_signature(r.path_url.lstrip('/'),
**params)
params["timestamp"] = int(time.time()) # 先加入 timestamp
signV1 = self.get_signature_v1(params, self.uid, self.sid)
signV2 = self.get_signature_v2(params, self.uid, self.sid)
r.headers["_sign"] = signV2 # headers 内还有一鉴权 !
if r.method == 'GET':
r.prepare_url(r.url,
params={
"signature": signV1,
"timestamp": params["timestamp"]
})
elif r.method == "POST":
params["signature"] = signV1
r.prepare_body(data=params, files=None)
return r
def demixing_problem(
model: nn.Module,
x0: torch.Tensor,
x1: torch.Tensor,
Q=None,
num_iter=1000,
clamp=True,
):
x0_shape = x0.shape
x1_shape = x1.shape
assert (
x0_shape == x1_shape
), f"Expected x0.shape == x1.shape but found {x0.shape} != {x1.shape}"
if (Q is not None) and isinstance(Q, torch.Tensor):
mixture = x0 + torch.matmul(Q, x1.view(-1, 1)).view(*x1_shape)
else:
mixture = x0 + x1
if clamp:
mixture.clamp_(0.0, 1.0)
model.eval()
mixture_params = model.encode(mixture.view(1, -1))
mixture_encoding = model.reparametrize(*mixture_params)
# Set requires_grad = False for all model parameters.
model.requires_grad_(False)
# For encoding vectors w0 and w1, set requires_grad = True.
w0 = (mixture_encoding.clone().detach().add_(
torch.randn_like(mixture_encoding), alpha=0.1).requires_grad_(True))
w1 = (mixture_encoding.clone().detach().add_(
torch.randn_like(mixture_encoding), alpha=0.1).requires_grad_(True))
# Acquire im0 = model.decode(w0), im1 = model.decode(w1)
# and compute loss = norm(y - im0 - im1, 2)**2 where
# w0.requires_grad = True and w1.requires_grad = True.
# Then after we call loss.backward, we should have updates for
# w0 and w1. Just gotta' pass w0 and w1 to the optimizer.
criterion = nn.MSELoss()
optimizer = optim.Adam([w0, w1], lr=1e-2)
logger = Logger()
for i in range(num_iter):
demixed0 = model.decode(w0)
demixed1 = model.decode(w1)
optimizer.zero_grad()
mixture_pred = (demixed0 + demixed1).squeeze()
loss = criterion(mixture_pred, mixture)
logger("iter", i)
logger("loss", loss.item())
loss.backward()
optimizer.step()
return (
demixed0,
w0,
demixed1,
w1,
mixture,
mixture_encoding,
optimizer,
logger,
)
class PKURunnerClient(object):
""" PKURunner 客户端类
封装各种 API 接口
Attributes:
class:
logger Logger 日志类实例
BaseUrl str 服务器 BaseUrl
instance:
studentID str iaaa 认证账号/学号
iaaa IAAAClient iaaa 认证客户端实例
access_token str iaaa 认证后的 token 字符串
auth PKURunnerAuth PKURunner 客户端鉴权类实例
headers dict 基础请求头
"""
logger = Logger("PKURunner")
BaseURL = "https://pkunewyouth.pku.edu.cn"
def __init__(self):
studentID = config.get("PKURunner", "StudentID")
password = config.get("PKURunner", "Password")
self.studentID = studentID
self.iaaa = IAAAClient(studentID, password)
self.access_token = self.iaaa.get_token()
self.auth = PKURunnerAuth(self.access_token)
@property
def headers(self):
return {
"User-Agent": "okhttp/3.10.0",
}
def __request(self, method, url, verify_success=True, **kwargs):
""" 网路请求函数模板，对返回结果做统一校验
Args:
method str 请求 method
url str 请求 url/path
verify_success bool 是否校验 success 字段 （默认 true），对于无 success 返回值的请求不需要校验
**kwargs 传给 requests.request 函数
Returns:
respJson jsonData json 数据
Raises:
PKURunnerRequestStatusError 请求状态码异常
PKURunnerUnauthorizedError 鉴权失败
PKURunnerSuccessStateError success 状态为 false
"""
if url[:7] != "http://" and url[:8] != "https://":
url = "{base}/{path}".format(base=self.BaseURL,
path=url.lstrip("/"))
headers = self.headers
headers.update(kwargs.pop("headers", {}))
resp = requests.request(method, url, headers=headers, **kwargs)
if not resp.ok:
if resp.text == "Unauthorized":
raise PKURunnerUnauthorizedError("token invalid")
else:
self.logger.error("resp.headers = %s" %
pretty_json(dict(resp.headers)))
self.logger.error("resp.text = %s" % resp.text)
raise PKURunnerRequestStatusError("resp.ok error")
else:
respJson = resp.json()
if verify_success and not respJson.get("success"):
self.logger.error(respJson)
raise PKURunnerSuccessStateError("resp.json error")
else:
self.logger.debug(
"resp.url = {url} \nresp.json = {json}".format(
url=resp.url, json=pretty_json(respJson)))
return respJson
def get(self, url, params={}, **kwargs):
return self.__request('GET', url, params=params, **kwargs)
def post(self, url, data={}, **kwargs):
return self.__request('POST', url, data=data, **kwargs)
def login(self):
""" 用户登录 刷新服务器 token 缓存
"""
self.access_token = self.iaaa.get_token(refresh=True) # 首先刷新
self.auth.refresh(self.access_token) # 更新 access_token
respJson = self.post("user", {
'access_token': self.access_token,
})
def get_latest_version(self):
""" 获取最新版本号
public API 无需鉴权
"""
respJson = self.get("public/client/android/curr_version",
verify_success=False)
def get_latest_version_for_offline(self):
""" 获取支持离线登录的最新版本
public API 无需鉴权
"""
respJson = self.get(
"https://raw.githubusercontent.com/pku-runner/pku-runner.github.io/android/public/client/android/curr_version",
verify_success=False)
def get_min_version(self):
""" 获取最低支持版本号
public API 无需鉴权
"""
respJson = self.get("public/client/android/min_version",
verify_success=False)
@unauthorized_retry(1)
def get_records(self):
""" 获得跑步记录列表
"""
respJson = self.get("record/{userId}".format(userId=self.studentID),
auth=self.auth)
@unauthorized_retry(1)
def get_record(self, recordId):
""" 获得单次跑步记录数据
"""
respJson = self.get("record/{userId}/{recordId}".format(
userId=self.studentID, recordId=recordId),
auth=self.auth)
json_dump("../cache/", "record.%s.json" % recordId, respJson)
@unauthorized_retry(1)
def get_record_status(self):
""" 跑步状态总览 （已跑、总里程、起止时间等）
"""
respJson = self.get(
"record/status/{userId}".format(userId=self.studentID),
auth=self.auth)
@unauthorized_retry(1)
def upload_record_without_photo(self, record):
""" 不带自拍，上传跑步记录
"""
abstract = sha256(
f'{self.studentID}_{record.date}_781f5106781f5106'.encode(
'utf-8')).hexdigest()[:32]
m = MultipartEncoder(
fields={
'userId': str(self.studentID),
'duration': str(record.duration),
'date': str(record.date), # 后端好像会根据日期来判断是否重复发包
'detail': json.dumps(record.detail), # 路径似乎并不会用来查重
'misc': json.dumps({"agent": "Android v1.2+"}),
'step': str(record.step),
'abstract': abstract,
})
# self.logger.debug(record.__dict__)
# self.logger.debug(m.to_string()) # 注意！ m.to_string() 只能输出一次，第二次将会输出空字节，因此不要用这个方法来调试！
# return
respJson = self.post("record/{userId}".format(userId=self.studentID),
data=m.to_string(),
headers={'Content-Type': m.content_type},
auth=self.auth)
if not respJson["data"]["verified"]:
raise PKURunnerNotVerifiedError(
"record is not verified, check your running params setting.")
@unauthorized_retry(1)
def get_badges(self):
""" 成就列表/徽章列表
"""
respJson = self.get(
"badge/user/{userId}".format(userId=self.studentID),
auth=self.auth)
def get_weather(self):
""" 获取天气信息
不需要鉴权
"""
respJson = self.get("weather/all", verify_success=False)
def run(self):
""" 项目主程序外部调用接口
"""
distance = config.getfloat("PKURunner", "distance") # 总距离 km
pace = config.getfloat("PKURunner", "pace") # 速度 min/km
stride_frequncy = config.getint("PKURunner",
"stride_frequncy") # 步频 step/min
record = Record(distance, pace, stride_frequncy)
self.upload_record_without_photo(record)
help='enables CUDA training')
parser.add_argument('--seed', type=int, default=1, metavar='S',
help='random seed (default: 1)')
parser.add_argument('--eval', type=bool, default=False,
help='evaluate the model')
parser.add_argument('--num_points', type=int, default=1024,
help='num of points to use')
parser.add_argument('--dropout', type=float, default=0.5,
help='dropout rate')
parser.add_argument('--model_path', type=str, default='', metavar='N',
help='Pretrained model path')
args = parser.parse_args()
_init_(args)
io = Logger('checkpoints/' + args.exp_name + '/run.log')
io.cprint(str(args))
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
io.cprint(
'Using GPU : ' + str(torch.cuda.current_device()) + ' from ' + str(torch.cuda.device_count()) + ' devices')
torch.cuda.manual_seed(args.seed)
else:
io.cprint('Using CPU')
if not args.eval:
train(args, io)
else:
test(args, io)
class JoyrunClient(object):
""" Joyrun 悦跑圈客户端类
Attributes:
class:
logger Logger 日志类实例
BaseUrl str API 基础链接
Cache_LoginInfo str 登录状态缓存 json 文件名
instance:
userName str 登录用户名
password str 登录密码
session request.Session requests 会话类实例
auth JoyrunAuth Jourun 请求鉴权类实例
uid int 用户 ID
sid str 会话 ID
base_headers dict 基础请求头
device_info_headers dict 设备信息请求头
"""
logger = Logger("joyrun")
BaseUrl = "https://api.thejoyrun.com"
Cache_LoginInfo = "Joyrun_LoginInfo.json"
def __init__(self):
self.userName = "******".format(
studentId=config.get("Joyrun", "StudentID"),
suffix=config.get("Joyrun", "suffix"))
self.password = config.get("Joyrun", "Password")
try:
cache = json_load(self.Cache_LoginInfo)
except (FileNotFoundError, JSONDecodeError):
cache = {}
if cache.get("userName") == self.userName:
self.uid = cache.get("uid", 0)
self.sid = cache.get("sid", '')
else: # userName 不匹配，则不使用缓存信息
self.uid = 0
self.sid = ''
self.session = requests.Session()
self.session.headers.update(self.base_headers)
self.session.headers.update(self.device_info_headers)
self.auth = JoyrunAuth(self.uid, self.sid)
if self.uid and self.sid: # 直接从缓存中读取登录状态
self.__update_loginInfo()
else:
self.login() # 否则重新登录
@property
def base_headers(self):
return {
"Accept-Language": "en_US",
"User-Agent": "okhttp/3.10.0",
"Host": "api.thejoyrun.com",
"Connection": "Keep-Alive",
}
@property
def device_info_headers(self):
return {
"MODELTYPE":
"Xiaomi MI 5",
"SYSVERSION":
"8.0.0",
"APPVERSION":
"4.2.0",
"MODELIMEI":
"861945034544449",
"APP_DEV_INFO":
"Android#4.2.0#Xiaomi MI 5#8.0.0#861945034544449#%s#xiaomi" %
(self.uid or 87808183),
}
def __reqeust(self, method, url, **kwargs):
""" 网路请求函数模板，对返回结果做统一校验
Args:
method str 请求 method
url str 请求 url/path
**kwargs 传给 requests.request 函数
Returns:
respJson jsonData json 数据
Raises:
JoyrunRequestStatusError 请求状态码异常
JoyrunRetStateError ret 字段非 0 -> 请求结果异常
JoyrunSidInvalidError sid 失效，登录状态异常
"""
if url[:7] != "http://" and url[:8] != "https://":
url = "{base}/{path}".format(
base=self.BaseUrl, path=url[1:]
if url[0] == '/' else url) # //user/login/normal 需要保留两个 '/' !
resp = self.session.request(method, url, **kwargs)
# self.logger.debug("request.url = %s" % resp.url)
# self.logger.debug("request.headers = %s" % resp.request.headers)
# self.logger.debug("request.body = %s" % resp.request.body)
# self.logger.debug("response.headers = %s" % resp.headers)
if not resp.ok:
self.logger.error("request.url = %s" % resp.url)
self.logger.error("request.headers = %s" %
pretty_json(dict(resp.request.headers)))
self.logger.error("session.cookies = %s" %
pretty_json(self.session.cookies.get_dict()))
if resp.request.method == 'POST':
self.logger.error("request.body = %s" % resp.request.body)
self.logger.error("response.text = %s" % resp.text)
raise JoyrunRequestStatusError("response.ok error")
respJson = resp.json()
if respJson.get("ret") != "0":
if respJson.get("ret") == "401": # sid 失效
raise JoyrunSidInvalidError("sid invalid")
else:
self.logger.error("response.json = %s" % pretty_json(respJson))
raise JoyrunRetStateError("response.json error")
self.logger.debug("request.url = %s" % resp.url)
self.logger.debug("response.json = %s" % pretty_json(respJson))
return respJson
def get(self, url, params={}, **kwargs):
return self.__reqeust('GET', url, params=params, **kwargs)
def post(self, url, data={}, **kwargs):
return self.__reqeust('POST', url, data=data, **kwargs)
def __update_loginInfo(self):
""" 更新登录状态信息
更新本地 uid, sid 记录
更新鉴权实例 uid, sid 记录
更新 cookies 信息
更新 headers 设备信息
"""
self.auth.reload(uid=self.uid, sid=self.sid)
loginCookie = "sid=%s&uid=%s" % (self.sid, self.uid)
self.session.headers.update({"ypcookie": loginCookie})
self.session.cookies.clear()
self.session.cookies.set("ypcookie", quote(loginCookie).lower())
self.session.headers.update(
self.device_info_headers) # 更新设备信息中的 uid 字段
def __parse_record(self, respJson):
""" 解析 get_record 返回的 json 包
"""
r = respJson["runrecord"]
r["altitude"] = json.loads(r["altitude"])
r["heartrate"] = json.loads(r["heartrate"])
r["stepcontent"] = [[json.loads(y) for y in x]
for x in json.loads(r["stepcontent"])]
r["stepremark"] = json.loads(r["stepremark"])
r["content"] = [json.loads(x) for x in r["content"].split("-")]
return respJson
def get_timestamp(self):
respJson = self.get("/GetTimestamp.aspx")
@sid_invalid_retry(1)
def get_dataMessages(self):
params = {
"lasttime": 0,
}
respJson = self.get("/dataMessages",
params,
auth=self.auth.reload(params))
def login(self):
""" 登录 API
"""
params = {
"username": self.userName,
"pwd": MD5(self.password).upper(),
}
respJson = self.get("//user/login/normal",
params,
auth=self.auth.reload(params))
self.sid = respJson['data']['sid']
self.uid = int(respJson['data']['user']['uid'])
json_dump(
self.Cache_LoginInfo,
{ # 缓存新的登录信息
"userName": self.userName,
"sid": self.sid,
"uid": self.uid
})
self.__update_loginInfo()
def logout(self):
""" 登出 API
登出后 sid 仍然不会失效 ！ 可能是闹着玩的 API ...
"""
respJson = self.post("/logout.aspx", auth=self.auth.reload())
@sid_invalid_retry(1)
def get_bindings(self):
respJson = self.get("//user/getbindings", auth=self.auth.reload())
@sid_invalid_retry(1)
def get_myInfo(self):
""" 获取用户信息 API
"""
payload = {
"touid": self.uid,
"option": "info",
}
respJson = self.post("/user.aspx",
payload,
auth=self.auth.reload(payload))
@sid_invalid_retry(1)
def get_myInfo_detail(self):
payload = {
"option": "get",
}
respJson = self.post("/oneclickdetails.aspx",
payload,
auth=self.auth.reload(payload))
@sid_invalid_retry(1)
def get_friends(self):
payload = {"dateline": 1, "option": "friends"}
respJson = self.post("/user.aspx",
payload,
auth=self.auth.reload(payload))
@sid_invalid_retry(1)
def get_feed_messages(self):
payload = {
"lasttime": 0,
}
respJson = self.post("/feedMessageList.aspx",
payload,
auth=self.auth.reload(payload))
@sid_invalid_retry(1)
def get_feed_remind(self):
respJson = self.post("/Social/GetFeedRemind.aspx",
auth=self.auth.reload())
@sid_invalid_retry(1)
def get_records(self):
""" 获取跑步记录 API
"""
payload = {
"year": 0,
}
respJson = self.post("/userRunList.aspx",
payload,
auth=self.auth.reload(payload))
@sid_invalid_retry(1)
def get_best_record(self):
payload = {
"touid": self.uid,
"option": "record",
}
respJson = self.post("/run/best",
payload,
auth=self.auth.reload(payload))
@sid_invalid_retry(1)
def get_record(self, fid):
""" 获取跑步单次记录详情 API
"""
payload = {
"fid": fid,
"wgs": 1,
}
respJson = self.post("/Run/GetInfo.aspx",
payload,
auth=self.auth.reload(payload))
json_dump("record.%s.json" % fid, respJson)
json_dump("record.%s.parse.json" % fid, self.__parse_record(respJson))
@sid_invalid_retry(1)
def upload_record(self, record):
""" 上传跑步记录
"""
payload = {
"altitude": record.altitude,
"private": 0,
"dateline": record.dateline,
"city": "北京",
"starttime": record.starttime,
"type": 1,
"content": record.content,
"second": record.second,
"stepcontent": record.stepcontent,
"province": "北京市",
"stepremark": record.stepremark,
"runid": record.runid,
"sampleinterval": record.sampleinterval,
"wgs": 1,
"nomoment": 1,
"meter": record.meter,
"heartrate": "[]",
"totalsteps": record.totalsteps,
"nodetime": record.nodetime,
"lasttime": record.lasttime,
"pausetime": "",
"timeDistance": record.timeDistance,
}
# self.logger.info(pretty_json(payload))
respJson = self.post("/po.aspx",
payload,
auth=self.auth.reload(payload))
def run(self):
""" 项目主程序外部调用接口
"""
distance = config.getfloat("Joyrun", "distance") # 总距离 km
pace = config.getfloat("Joyrun", "pace") # 速度 min/km
stride_frequncy = config.getint("Joyrun",
"stride_frequncy") # 步频 step/min
record_type = config.get("Joyrun", "record_type") # 跑步记录类型
record_number = config.getint("Joyrun", "record_number") # 跑步记录编号
if record_type == "54":
record_instances = record.__Record_54_Instance__
elif record_type == "wmlake":
record_instances = record.__Record_WMLake_Instance__
elif record_type == "random":
record_instances = getattr(
record,
random.choice(
["__Record_54_Instance__", "__Record_WMLake_Instance__"]))
else:
raise RecordTypeError(
"unsupport record type '%s' ! valid type = ['54','wmlake','random']"
% record_type)
if record_number == 0:
Record = getattr(record, random.choice(record_instances))
elif record_number < 0 or record_number > len(record_instances):
raise RecordNumberError(
"invalid record number '%s' ! valid range = [0,%s]" %
(record_number, len(record_instances)))
else:
Record = getattr(record, record_instances[record_number - 1])
_record = Record(distance, pace, stride_frequncy)
self.upload_record(_record)
adv.data = torch.where(adv.data > img.data + eps, img.data + eps,
adv.data)
adv.data = torch.where(adv.data < img.data - eps, img.data - eps,
adv.data)
adv.data.clamp_(0.0, 1.0)
adv.grad.data.zero_()
return adv.detach()
os.environ["CUDA_VISIBLE_DEVICES"] = "2, 3"
args.cuda = not args.no_cuda and torch.cuda.is_available()
log_filename = 'res18n_ft_adv_k{}.txt'.format(args.nmb_cluster)
sys.stdout = Logger(os.path.join(args.save_dir, log_filename))
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
else:
print("No cuda participate.")
kwargs = {'num_workers': 4, 'pin_memory': True} if args.cuda else {}
train_loader = torch.utils.data.DataLoader(datasets.CIFAR10(
'../data',
train=True,
download=True,
transform=transforms.Compose([
transforms.Pad(4),
transforms.RandomCrop(32),
def main():
global args
args = parser.parse_args()
#fix random seeds
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
np.random.seed(args.seed)
best_prec1 = 0
# load model
model = load_model(args.model)
model.cuda()
cudnn.benchmark = True
# freeze the features layers
for param in model.features.parameters():
param.requires_grad = False
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
# data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if args.tencrops:
transformations_val = [
transforms.Resize(256),
transforms.TenCrop(224),
transforms.Lambda(lambda crops: torch.stack(
[normalize(transforms.ToTensor()(crop)) for crop in crops])),
]
else:
transformations_val = [
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(), normalize
]
transformations_train = [
transforms.Resize(256),
transforms.CenterCrop(256),
transforms.RandomCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normalize
]
train_dataset = datasets.ImageFolder(
traindir, transform=transforms.Compose(transformations_train))
val_dataset = datasets.ImageFolder(
valdir, transform=transforms.Compose(transformations_val))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(val_dataset,
batch_size=int(args.batch_size /
2),
shuffle=False,
num_workers=args.workers)
# logistic regression
reglog = RegLog(args.conv, len(train_dataset.classes)).cuda()
optimizer = torch.optim.SGD(filter(lambda x: x.requires_grad,
reglog.parameters()),
args.lr,
momentum=args.momentum,
weight_decay=10**args.weight_decay)
# create logs
exp_log = os.path.join(args.exp, 'log')
if not os.path.isdir(exp_log):
os.makedirs(exp_log)
loss_log = Logger(os.path.join(exp_log, 'loss_log'))
prec1_log = Logger(os.path.join(exp_log, 'prec1'))
prec5_log = Logger(os.path.join(exp_log, 'prec5'))
for epoch in range(args.epochs):
end = time.time()
# train for one epoch
train(train_loader, model, reglog, criterion, optimizer, epoch)
# evaluate on validation set
prec1, prec5, loss = validate(val_loader, model, reglog, criterion)
loss_log.log(loss)
prec1_log.log(prec1)
prec5_log.log(prec5)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
if is_best:
filename = 'model_best.pth.tar'
else:
filename = 'checkpoint.pth.tar'
torch.save(
{
'epoch': epoch + 1,
'arch': 'alexnet',
'state_dict': model.state_dict(),
'prec5': prec5,
'best_prec1': best_prec1,
'optimizer': optimizer.state_dict(),
}, os.path.join(args.exp, filename))
import re
from util import Logger, LAMBDA_NAME
from util import invokeLambda
from util import POSTBACK_TYPES, AIR_EVENT_TYPES, LINE_EVENT_TYPES, LAMBDAS
from util import LINE_MESSAGE_TEMPLATES, LINE_MESSAGE_TEXTS
# Logger
logger = Logger(LAMBDA_NAME)
# TODO: Remove the list structure
# (User) Reply next class info
def cmd_nextClass(event):
'''
Success response =
[{'Status': 'handle_nextClass: OK', 'Data': {'memberIid': 'recMgb6f5sfuhVWAs', 'classId': '1900322', 'classTime': '1114 09:00', 'classLocation': 'home', 'classTrainer': 'CY'}}]
'''
# Get next class info
resPayload = invokeLambda(LAMBDAS.AIRTABLE, {
'eventType': AIR_EVENT_TYPES.NEXT_CLASS,
'lineUserId': event.source.user_id
})
resData = resPayload and resPayload[0]['Data']
logger.debug('Next class info: {}'.format(resData))
# Reply to the message
invokeLambda(LAMBDAS.LINE, {
'eventType': LINE_EVENT_TYPES.REPLY,
'lineReplyToken': event.reply_token,
**({
'replyMessage': LINE_MESSAGE_TEXTS.NEXT_CLASS_RECORD,
def main(args):
# fix random seeds
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
np.random.seed(args.seed)
device = torch.device('cuda:0' if torch.cuda.is_available() else "cpu")
print(device)
criterion = nn.CrossEntropyLoss()
cluster_log = Logger(os.path.join(args.exp, '../..', 'clusters.pickle'))
# CNN
if args.verbose:
print('Architecture: {}'.format(args.arch))
'''
##########################################
##########################################
# Model definition
##########################################
##########################################'''
model = models.__dict__[args.arch](bn=True, num_cluster=args.nmb_cluster, num_category=args.nmb_category)
fd = int(model.cluster_layer[0].weight.size()[1]) # due to transpose, fd is input dim of W (in dim, out dim)
model.cluster_layer = None
model.category_layer = None
model.features = torch.nn.DataParallel(model.features)
model = model.double()
model.to(device)
cudnn.benchmark = True
if args.optimizer is 'Adam':
print('Adam optimizer: conv')
optimizer_body = torch.optim.Adam(
filter(lambda x: x.requires_grad, model.parameters()),
lr=args.lr_Adam,
betas=(0.9, 0.999),
weight_decay=10 ** args.wd,
)
else:
print('SGD optimizer: conv')
optimizer_body = torch.optim.SGD(
filter(lambda x: x.requires_grad, model.parameters()),
lr=args.lr_SGD,
momentum=args.momentum,
weight_decay=10 ** args.wd,
)
'''
###############
###############
category_layer
###############
###############
'''
model.category_layer = nn.Sequential(
nn.Linear(fd, args.nmb_category),
nn.Softmax(dim=1),
)
model.category_layer[0].weight.data.normal_(0, 0.01)
model.category_layer[0].bias.data.zero_()
model.category_layer = model.category_layer.double()
model.category_layer.to(device)
if args.optimizer is 'Adam':
print('Adam optimizer: conv')
optimizer_category = torch.optim.Adam(
filter(lambda x: x.requires_grad, model.category_layer.parameters()),
lr=args.lr_Adam,
betas=(0.9, 0.999),
weight_decay=10 ** args.wd,
)
else:
print('SGD optimizer: conv')
optimizer_category = torch.optim.SGD(
filter(lambda x: x.requires_grad, model.category_layer.parameters()),
lr=args.lr_SGD,
momentum=args.momentum,
weight_decay=10 ** args.wd,
)
'''
########################################
########################################
Create echogram sampling index
########################################
########################################'''
print('Sample echograms.')
_, dataset_semi = sampling_echograms_full(args)
# dataloader_cp = torch.utils.data.DataLoader(dataset_cp,
# shuffle=False,
# batch_size=args.batch,
# num_workers=args.workers,
# drop_last=False,
# pin_memory=True)
dataloader_semi = torch.utils.data.DataLoader(dataset_semi,
shuffle=False,
batch_size=args.batch,
num_workers=args.workers,
drop_last=False,
pin_memory=True)
dataset_test = sampling_echograms_test(args)
dataloader_test = torch.utils.data.DataLoader(dataset_test,
shuffle=False,
batch_size=args.batch,
num_workers=args.workers,
drop_last=False,
pin_memory=True)
# clustering algorithm to use
deepcluster = clustering.__dict__[args.clustering](args.nmb_cluster, args.pca)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
# remove top located layer parameters from checkpoint
copy_checkpoint_state_dict = checkpoint['state_dict'].copy()
for key in list(copy_checkpoint_state_dict):
if 'cluster_layer' in key:
del copy_checkpoint_state_dict[key]
# if 'category_layer' in key:
# del copy_checkpoint_state_dict[key]
checkpoint['state_dict'] = copy_checkpoint_state_dict
model.load_state_dict(checkpoint['state_dict'])
optimizer_body.load_state_dict(checkpoint['optimizer_body'])
optimizer_category.load_state_dict(checkpoint['optimizer_category'])
category_save = os.path.join(args.exp, '../..', 'category_layer.pth.tar')
if os.path.isfile(category_save):
category_layer_param = torch.load(category_save)
model.category_layer.load_state_dict(category_layer_param)
print("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
# creating checkpoint repo
exp_check = os.path.join(args.exp, '../..', 'checkpoints')
if not os.path.isdir(exp_check):
os.makedirs(exp_check)
'''
#######################
#######################
PRETRAIN: commented
#######################
#######################'''
''' # if args.start_epoch < args.pretrain_epoch:
# if os.path.isfile(os.path.join(args.exp, '..', 'pretrain_loss_collect.pickle')):
# with open(os.path.join(args.exp, '..', 'pretrain_loss_collect.pickle'), "rb") as f:
# pretrain_loss_collect = pickle.load(f)
# else:
# pretrain_loss_collect = [[], [], [], [], []]
# print('Start pretraining with %d percent of the dataset from epoch %d/(%d)'
# % (int(args.semi_ratio * 100), args.start_epoch, args.pretrain_epoch))
# model.cluster_layer = None
#
# for epoch in range(args.start_epoch, args.pretrain_epoch):
# with torch.autograd.set_detect_anomaly(True):
# pre_loss, pre_accuracy = supervised_train(loader=dataloader_semi,
# model=model,
# crit=criterion,
# opt_body=optimizer_body,
# opt_category=optimizer_category,
# epoch=epoch, device=device, args=args)
# test_loss, test_accuracy = test(dataloader_test, model, criterion, device, args)
#
# # print log
# if args.verbose:
# print('###### Epoch [{0}] ###### \n'
# 'PRETRAIN tr_loss: {1:.3f} \n'
# 'TEST loss: {2:.3f} \n'
# 'PRETRAIN tr_accu: {3:.3f} \n'
# 'TEST accu: {4:.3f} \n'.format(epoch, pre_loss, test_loss, pre_accuracy, test_accuracy))
# pretrain_loss_collect[0].append(epoch)
# pretrain_loss_collect[1].append(pre_loss)
# pretrain_loss_collect[2].append(test_loss)
# pretrain_loss_collect[3].append(pre_accuracy)
# pretrain_loss_collect[4].append(test_accuracy)
#
# torch.save({'epoch': epoch + 1,
# 'arch': args.arch,
# 'state_dict': model.state_dict(),
# 'optimizer_body': optimizer_body.state_dict(),
# 'optimizer_category': optimizer_category.state_dict(),
# },
# os.path.join(args.exp, '..', 'checkpoint.pth.tar'))
# torch.save(model.category_layer.state_dict(), os.path.join(args.exp, '..', 'category_layer.pth.tar'))
#
# with open(os.path.join(args.exp, '..', 'pretrain_loss_collect.pickle'), "wb") as f:
# pickle.dump(pretrain_loss_collect, f)
#
# if (epoch+1) % args.checkpoints == 0:
# path = os.path.join(
# args.exp, '..',
# 'checkpoints',
# 'checkpoint_' + str(epoch) + '.pth.tar',
# )
# if args.verbose:
# print('Save checkpoint at: {0}'.format(path))
# torch.save({'epoch': epoch + 1,
# 'arch': args.arch,
# 'state_dict': model.state_dict(),
# 'optimizer_body': optimizer_body.state_dict(),
# 'optimizer_category': optimizer_category.state_dict(),
# }, path)'''
if os.path.isfile(os.path.join(args.exp, '../..', 'loss_collect.pickle')):
with open(os.path.join(args.exp, '../..', 'loss_collect.pickle'), "rb") as f:
loss_collect = pickle.load(f)
else:
loss_collect = [[], [], [], [], [], [], []]
if os.path.isfile(os.path.join(args.exp, '../..', 'nmi_collect.pickle')):
with open(os.path.join(args.exp, '../..', 'nmi_collect.pickle'), "rb") as ff:
nmi_save = pickle.load(ff)
else:
nmi_save = []
'''
#######################
#######################
MAIN TRAINING
#######################
#######################'''
for epoch in range(args.start_epoch, args.epochs):
end = time.time()
model.classifier = nn.Sequential(*list(model.classifier.children())[:-1]) # remove ReLU at classifier [:-1]
model.cluster_layer = None
model.category_layer = None
'''
#######################
#######################
PSEUDO-LABEL GENERATION
#######################
#######################
'''
print('Cluster the features')
features_train, input_tensors_train, labels_train = compute_features(dataloader_semi, model, len(dataset_semi), device=device, args=args)
clustering_loss, pca_features = deepcluster.cluster(features_train, verbose=args.verbose)
nan_location = np.isnan(pca_features)
inf_location = np.isinf(pca_features)
if (not np.allclose(nan_location, 0)) or (not np.allclose(inf_location, 0)):
print('PCA: Feature NaN or Inf found. Nan count: ', np.sum(nan_location), ' Inf count: ', np.sum(inf_location))
print('Skip epoch ', epoch)
torch.save(pca_features, 'tr_pca_NaN_%d.pth.tar' % epoch)
torch.save(features_train, 'tr_feature_NaN_%d.pth.tar' % epoch)
continue
print('Assign pseudo labels')
size_cluster = np.zeros(len(deepcluster.images_lists))
for i, _list in enumerate(deepcluster.images_lists):
size_cluster[i] = len(_list)
print('size in clusters: ', size_cluster)
img_label_pair_train = zip_img_label(input_tensors_train, labels_train)
train_dataset = clustering.cluster_assign(deepcluster.images_lists,
img_label_pair_train) # Reassigned pseudolabel
# uniformly sample per target
sampler_train = UnifLabelSampler(int(len(train_dataset)),
deepcluster.images_lists)
train_dataloader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch,
shuffle=False,
num_workers=args.workers,
sampler=sampler_train,
pin_memory=True,
)
'''
####################################################################
####################################################################
TRSNSFORM MODEL FOR SELF-SUPERVISION // SEMI-SUPERVISION
####################################################################
####################################################################
'''
# Recover classifier with ReLU (that is not used in clustering)
mlp = list(model.classifier.children()) # classifier that ends with linear(512 * 128). No ReLU at the end
mlp.append(nn.ReLU(inplace=True).to(device))
model.classifier = nn.Sequential(*mlp)
model.classifier.to(device)
'''SELF-SUPERVISION (PSEUDO-LABELS)'''
model.category_layer = None
model.cluster_layer = nn.Sequential(
nn.Linear(fd, args.nmb_cluster), # nn.Linear(4096, num_cluster),
nn.Softmax(dim=1), # should be removed and replaced by ReLU for category_layer
)
model.cluster_layer[0].weight.data.normal_(0, 0.01)
model.cluster_layer[0].bias.data.zero_()
model.cluster_layer = model.cluster_layer.double()
model.cluster_layer.to(device)
''' train network with clusters as pseudo-labels '''
with torch.autograd.set_detect_anomaly(True):
pseudo_loss, semi_loss, semi_accuracy = semi_train(train_dataloader, dataloader_semi, model, fd, criterion,
optimizer_body, optimizer_category, epoch, device=device, args=args)
# save checkpoint
if (epoch + 1) % args.checkpoints == 0:
path = os.path.join(
args.exp, '../..',
'checkpoints',
'checkpoint_' + str(epoch) + '.pth.tar',
)
if args.verbose:
print('Save checkpoint at: {0}'.format(path))
torch.save({'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'optimizer_body': optimizer_body.state_dict(),
'optimizer_category': optimizer_category.state_dict(),
}, path)
'''
##############
##############
# TEST phase
##############
##############
'''
test_loss, test_accuracy, test_pred, test_label = test(dataloader_test, model, criterion, device, args)
'''Save prediction of the test set'''
if (epoch % args.save_epoch == 0):
with open(os.path.join(args.exp, '../..', 'sup_epoch_%d_te.pickle' % epoch), "wb") as f:
pickle.dump([test_pred, test_label], f)
if args.verbose:
print('###### Epoch [{0}] ###### \n'
'Time: {1:.3f} s\n'
'Pseudo tr_loss: {2:.3f} \n'
'SEMI tr_loss: {3:.3f} \n'
'TEST loss: {4:.3f} \n'
'Clustering loss: {5:.3f} \n'
'SEMI accu: {6:.3f} \n'
'TEST accu: {7:.3f} \n'
.format(epoch, time.time() - end, pseudo_loss, semi_loss,
test_loss, clustering_loss, semi_accuracy, test_accuracy))
try:
nmi = normalized_mutual_info_score(
clustering.arrange_clustering(deepcluster.images_lists),
clustering.arrange_clustering(cluster_log.data[-1])
)
nmi_save.append(nmi)
print('NMI against previous assignment: {0:.3f}'.format(nmi))
with open(os.path.join(args.exp, '../..', 'nmi_collect.pickle'), "wb") as ff:
pickle.dump(nmi_save, ff)
except IndexError:
pass
print('####################### \n')
# save cluster assignments
cluster_log.log(deepcluster.images_lists)
# save running checkpoint
torch.save({'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'optimizer_body': optimizer_body.state_dict(),
'optimizer_category': optimizer_category.state_dict(),
},
os.path.join(args.exp, '../..', 'checkpoint.pth.tar'))
torch.save(model.category_layer.state_dict(), os.path.join(args.exp, '../..', 'category_layer.pth.tar'))
loss_collect[0].append(epoch)
loss_collect[1].append(pseudo_loss)
loss_collect[2].append(semi_loss)
loss_collect[3].append(clustering_loss)
loss_collect[4].append(test_loss)
loss_collect[5].append(semi_accuracy)
loss_collect[6].append(test_accuracy)
with open(os.path.join(args.exp, '../..', 'loss_collect.pickle'), "wb") as f:
pickle.dump(loss_collect, f)
'''
############################
############################
# PSEUDO-LABEL GEN: Test set
############################
############################
'''
model.classifier = nn.Sequential(*list(model.classifier.children())[:-1]) # remove ReLU at classifier [:-1]
model.cluster_layer = None
model.category_layer = None
print('TEST set: Cluster the features')
features_te, input_tensors_te, labels_te = compute_features(dataloader_test, model, len(dataset_test),
device=device, args=args)
clustering_loss_te, pca_features_te = deepcluster.cluster(features_te, verbose=args.verbose)
mlp = list(model.classifier.children()) # classifier that ends with linear(512 * 128). No ReLU at the end
mlp.append(nn.ReLU(inplace=True).to(device))
model.classifier = nn.Sequential(*mlp)
model.classifier.to(device)
nan_location = np.isnan(pca_features_te)
inf_location = np.isinf(pca_features_te)
if (not np.allclose(nan_location, 0)) or (not np.allclose(inf_location, 0)):
print('PCA: Feature NaN or Inf found. Nan count: ', np.sum(nan_location), ' Inf count: ',
np.sum(inf_location))
print('Skip epoch ', epoch)
torch.save(pca_features_te, 'te_pca_NaN_%d.pth.tar' % epoch)
torch.save(features_te, 'te_feature_NaN_%d.pth.tar' % epoch)
continue
# save patches per epochs
cp_epoch_out = [features_te, deepcluster.images_lists, deepcluster.images_dist_lists, input_tensors_te,
labels_te]
if (epoch % args.save_epoch == 0):
with open(os.path.join(args.exp, '../..', 'cp_epoch_%d_te.pickle' % epoch), "wb") as f:
pickle.dump(cp_epoch_out, f)
with open(os.path.join(args.exp, '../..', 'pca_epoch_%d_te.pickle' % epoch), "wb") as f:
pickle.dump(pca_features_te, f)
parser.add_argument('--net', type=str, default='AlexNet', help="base network type")
parser.add_argument('--prefix', type=str, default='hashnet', help="save path prefix")
parser.add_argument('--snapshot', type=str, default='iter_10000', help="model path prefix")
parser.add_argument('--batch_size', type=int, default=16, help="testing batch size")
parser.add_argument('--test_10crop', default=True, help='use TenCrop transform')
parser.add_argument('--preload', default=False, action='store_true')
args = parser.parse_args()
args.output_path = f'./snapshot/{args.dataset}_{str(args.bit)}bit_{args.net}_{args.prefix}'
args.snapshot_path = f'{args.output_path}/model.pth'
args.database_path = f'./data/{args.dataset}/database.txt'
args.test_path = f'./data/{args.dataset}/test.txt'
args.R = R[args.dataset]
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpus
sys.stdout = Logger(osp.join(args.output_path, "test.log"))
print("test start")
pprint(args)
if args.preload == True:
print("loading code and label ...")
code_and_label = load_code_and_label(args.output_path)
else:
print("calculating code and label ...")
code_and_label = predict(args)
print("saving code and label ...")
save_code_and_label(code_and_label, args.output_path)
print("saving done")
db_feats = code_and_label['db_feats']
db_codes = code_and_label['db_codes']
def main():
global args
args = parser.parse_args()
# fix random seeds
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
np.random.seed(args.seed)
# CNN
#if args.verbose:
# print('Architecture: {}'.format(args.arch))
#model = models.__dict__[args.arch](sobel=args.sobel)
model = models.vgg16(pretrained=None)
model.classifier = nn.Sequential(
nn.Linear(512 * 7 * 7, 4096),
nn.ReLU(True),
nn.Dropout(0.5),
nn.Linear(4096, 4096),
nn.ReLU(True),
)
model.top_layer = nn.Linear(4096, 257)
def forward(self, x):
x = self.features(x)
x = x.view(x.size(0), -1)
x = self.classifier(x)
if self.top_layer:
x = self.top_layer(x)
return x
param = torch.load('/deepcluster/finetune/checkpoint_s.tar')
model.load_state_dict(param)
fd = int(model.top_layer.weight.size()[1])
model.top_layer = None
model.features = torch.nn.DataParallel(model.features)
model.cuda()
cudnn.benchmark = True
# create optimizer
optimizer = torch.optim.SGD(
filter(lambda x: x.requires_grad, model.parameters()),
lr=args.lr,
momentum=args.momentum,
weight_decay=10**args.wd,
)
# define loss function
criterion = nn.CrossEntropyLoss().cuda()
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
# remove top_layer parameters from checkpoint
for key in checkpoint['state_dict']:
if 'top_layer' in key:
del checkpoint['state_dict'][key]
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
# creating checkpoint repo
exp_check = os.path.join(args.exp, 'checkpoints')
if not os.path.isdir(exp_check):
os.makedirs(exp_check)
# creating cluster assignments log
cluster_log = Logger(os.path.join(args.exp, 'clusters'))
# preprocessing of data
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
tra = [
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(), normalize
]
# load the data
end = time.time()
dataset = datasets.ImageFolder(args.data,
transform=transforms.Compose(tra))
if args.verbose: print('Load dataset: {0:.2f} s'.format(time.time() - end))
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch,
num_workers=args.workers,
pin_memory=True)
# clustering algorithm to use
deepcluster = clustering.__dict__[args.clustering](args.nmb_cluster)
# training convnet with DeepCluster
for epoch in range(args.start_epoch, args.epochs):
end = time.time()
# remove head
model.top_layer = None
model.classifier = nn.Sequential(
*list(model.classifier.children())[:-1])
# get the features for the whole dataset
features = compute_features(dataloader, model, len(dataset))
# cluster the features
clustering_loss = deepcluster.cluster(features, verbose=args.verbose)
# assign pseudo-labels
train_dataset = clustering.cluster_assign(deepcluster.images_lists,
dataset.imgs)
# uniformely sample per target
sampler = UnifLabelSampler(int(args.reassign * len(train_dataset)),
deepcluster.images_lists)
train_dataloader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch,
num_workers=args.workers,
sampler=sampler,
pin_memory=True,
)
# set last fully connected layer
mlp = list(model.classifier.children())
mlp.append(nn.ReLU(inplace=True).cuda())
model.classifier = nn.Sequential(*mlp)
model.top_layer = nn.Linear(fd, len(deepcluster.images_lists))
model.top_layer.weight.data.normal_(0, 0.01)
model.top_layer.bias.data.zero_()
model.top_layer.cuda()
# train network with clusters as pseudo-labels
end = time.time()
loss = train(train_dataloader, model, criterion, optimizer, epoch)
# print log
if args.verbose:
print('###### Epoch [{0}] ###### \n'
'Time: {1:.3f} s\n'
'Clustering loss: {2:.3f} \n'
'ConvNet loss: {3:.3f}'.format(epoch,
time.time() - end,
clustering_loss, loss))
try:
nmi = normalized_mutual_info_score(
clustering.arrange_clustering(deepcluster.images_lists),
clustering.arrange_clustering(cluster_log.data[-1]))
print('NMI against previous assignment: {0:.3f}'.format(nmi))
except IndexError:
pass
print('####################### \n')
# save running checkpoint
torch.save(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()
}, os.path.join(args.exp, 'checkpoint.pth.tar'))
# save cluster assignments
cluster_log.log(deepcluster.images_lists)
import json
import os
import re
import sys
from util import Logger, prjs
from utils import check_fix_config_data
logger = Logger('check_create_config_file')
configfilepath = sys.argv[1]
root_abs_path = sys.argv[2]
username = os.getlogin()
isfile = os.path.isfile(configfilepath)
is_in_dev = 'gbete' in username or 'gilad' in username
prjs(
dict(configfilepath=configfilepath,
root_abs_path=root_abs_path,
username=username,
isfile=isfile,
is_in_dev=is_in_dev))
if not isfile: # not found
config = dict(root_abs_path=root_abs_path,
dev=is_in_dev,
vid_silence_len=0,
last_page='new_test',
experiment_type='test',
subjects=[username],
truth_file_path="experiments/truths/fur_elise_B.txt",
from odl.contrib.fom import mean_squared_error, ssim
import datetime
import sys
import os
# Seed randomness for reproducability in validation
np.random.seed(0)
# Set up save-paths and output file
save_path = 'Give save path'
time_str = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
file_name = os.path.splitext(os.path.basename(__file__))[0]
output_filename = (save_path + 'Output_' + file_name + '_' +
time_str + '.txt')
sys.stdout = Logger(output_filename) # Creates logger that writes to file
# Start the tensorflow session
sess = tf.InteractiveSession()
# Create ODL data structures
size = 512
space = odl.uniform_discr([-128, -128], [128, 128], [size, size],
dtype='float32', weighting=1.0)
angle_partition = odl.uniform_partition(0, 2 * np.pi, 1000)
detector_partition = odl.uniform_partition(-360, 360, 1000)
geometry = odl.tomo.FanFlatGeometry(angle_partition, detector_partition,
src_radius=500, det_radius=500)
import paths
import rospy
import shutil
from bwi_scavenger_msgs.msg import DarknetAddTrainingFile
from bwi_scavenger_msgs.msg import DarknetStartTraining
from bwi_scavenger_msgs.msg import DatabaseFile
from darknet_structure import *
from globals import *
from util import Logger
from sensor_msgs.msg import Image
METADATA_PAIRING_DELIMITER = "="
METADATA_VALUES_DELIMITER = ","
METADATA_KEY_NETS = "nets"
log = Logger("darknet_node")
pub_send_file = None
nets = {}
def load_metadata():
"""Parses darknet.dat and rebuilds the Darknetwork containers from disk.
"""
src = force_open_read(paths.dnnode_meta)
for line in src.readlines():
tokens = line.strip().split(METADATA_PAIRING_DELIMITER)
key = tokens[0]
values = [
x.strip() for x in tokens[1].split(METADATA_VALUES_DELIMITER)
]
# logger
# model
model = Model(**model_config).to(0)
# optimizer
optimizer = AdamOptimizer(params=model.parameters(),
lr=exp_config['lr'],
grad_clip_value=exp_config['grad_clip_value'],
grad_clip_norm=exp_config['grad_clip_norm'])
logger_on = True
if logger_on:
logger = Logger(exp_config, model_config, data_config)
# train / val loop
for epoch in range(exp_config['n_epochs']):
print('Epoch:', epoch)
if logger_on:
logger.log(train(train_data, model, optimizer, eval_length), 'train')
logger.log(
validation(val_data, model, eval_length, use_mean_pred=True),
'val')
logger.save(model)
else:
train(train_data, model, optimizer, eval_length)
validation(val_data, model, eval_length)
"""
MinecraftServer
- Minecraft Server written in Python :)
"""
from util import Logger, PycraftFactory
from twisted.internet import reactor
PORT = 25565
print(Logger().success('Server is listening on port :' + str(PORT)))
FACTORY = PycraftFactory()
FACTORY.listen('', PORT)
reactor.run()
def main(args):
if args.checkpoint == '':
args.checkpoint = "checkpoints/ic15_%s_bs_%d_ep_%d" % (
args.arch, args.batch_size, args.n_epoch)
if args.pretrain:
if 'synth' in args.pretrain:
args.checkpoint += "_pretrain_synth"
else:
args.checkpoint += "_pretrain_ic17"
print('checkpoint path: %s' % args.checkpoint)
print('init lr: %.8f' % args.lr)
print('schedule: ', args.schedule)
sys.stdout.flush()
if not os.path.isdir(args.checkpoint):
os.makedirs(args.checkpoint)
kernel_num = 7
min_scale = 0.4
start_epoch = 0
#points dataloader
data_loader = IC15LoaderWdp(is_transform=True,
img_size=args.img_size,
kernel_num=kernel_num,
min_scale=min_scale)
# data_loader = IC15Loader(is_transform=True, img_size=args.img_size, kernel_num=kernel_num, min_scale=min_scale)
train_loader = torch.utils.data.DataLoader(
data_loader,
batch_size=args.batch_size,
shuffle=True,
# shuffle=False,
num_workers=0,
drop_last=True,
pin_memory=True)
if args.arch == "resnet50":
model = models.resnet50(pretrained=True, num_classes=kernel_num)
elif args.arch == "resnet101":
model = models.resnet101(pretrained=True, num_classes=kernel_num)
elif args.arch == "resnet152":
model = models.resnet152(pretrained=True, num_classes=kernel_num)
model = torch.nn.DataParallel(model).cuda()
if hasattr(model.module, 'optimizer'):
optimizer = model.module.optimizer
else:
optimizer = torch.optim.SGD(model.parameters(),
lr=args.lr,
momentum=0.99,
weight_decay=5e-4)
title = 'icdar2015'
if args.pretrain:
print('Using pretrained model.')
assert os.path.isfile(
args.pretrain), 'Error: no checkpoint directory found!'
checkpoint = torch.load(args.pretrain)
model.load_state_dict(checkpoint['state_dict'])
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title)
logger.set_names(
['Learning Rate', 'Train Loss', 'Train Acc.', 'Train IOU.'])
elif args.resume:
print('Resuming from checkpoint.')
assert os.path.isfile(
args.resume), 'Error: no checkpoint directory found!'
checkpoint = torch.load(args.resume)
start_epoch = checkpoint['epoch']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
logger = Logger(os.path.join(args.checkpoint, 'log.txt'),
title=title,
resume=True)
else:
print('Training from scratch.')
logger = Logger(os.path.join(args.checkpoint, 'log.txt'), title=title)
logger.set_names(
['Learning Rate', 'Train Loss', 'Train Acc.', 'Train IOU.'])
for epoch in range(start_epoch, args.n_epoch):
adjust_learning_rate(args, optimizer, epoch)
print('\nEpoch: [%d | %d] LR: %f' %
(epoch + 1, args.n_epoch, optimizer.param_groups[0]['lr']))
train_loss, train_te_acc, train_ke_acc, train_te_iou, train_ke_iou = train(
train_loader, model, dice_loss, optimizer, epoch)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'lr': args.lr,
'optimizer': optimizer.state_dict(),
},
checkpoint=args.checkpoint)
logger.append([
optimizer.param_groups[0]['lr'], train_loss, train_te_acc,
train_te_iou
])
logger.close()
def main():
global args
args = parser.parse_args()
# fix random seeds
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
np.random.seed(args.seed)
logs = []
# CNN
if args.verbose:
print('Architecture: {}'.format(args.arch))
if args.arch == 'inceptionv1':
model = models.__dict__[args.arch](
sobel=args.sobel,
weight_file='/home/farbod/honours/convert/kit_pytorch.npy')
else:
model = models.__dict__[args.arch](sobel=args.sobel)
fd = int(model.top_layer.weight.size()[1])
model.top_layer = None
if args.arch == 'inceptionv1':
for key in model.modules():
if isinstance(key, nn.Module): continue
key = torch.nn.DataParallel(key).cuda()
else:
model.features = torch.nn.DataParallel(model.features)
model.cuda()
cudnn.benchmark = True
#for param in model.parameters():
# param.requires_grad = False
#for param in model.classifier.parameters():
# param.requires_grad = True
# create optimizer
optimizer = torch.optim.SGD(
filter(lambda x: x.requires_grad, model.parameters()),
lr=args.lr,
momentum=args.momentum,
weight_decay=10**args.wd,
)
# define loss function
criterion = nn.CrossEntropyLoss().cuda()
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
#args.start_epoch = checkpoint['epoch']
# remove top_layer parameters from checkpoint
for key in checkpoint['state_dict']:
if 'top_layer' in key:
del checkpoint['state_dict'][key]
model.load_state_dict(checkpoint['state_dict'])
#optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
# creating checkpoint repo
exp_check = os.path.join(args.exp, 'checkpoints')
if not os.path.isdir(exp_check):
os.makedirs(exp_check)
plot_dir = os.path.join(args.exp, 'plots')
if not os.path.isdir(plot_dir):
os.makedirs(plot_dir)
# creating cluster assignments log
cluster_log = Logger(os.path.join(args.exp, 'clusters'))
# preprocessing of data
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
#normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5],
# std=[0.5, 0.5, 0.5])
tra = [
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(), normalize
]
# load the data
end = time.time()
dataset = datasets.ImageFolder(args.data,
transform=transforms.Compose(tra))
if args.verbose: print('Load dataset: {0:.2f} s'.format(time.time() - end))
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=args.batch,
num_workers=args.workers,
pin_memory=True)
# get ground truth labels for nmi
num_classes = 65
labels = [[] for i in range(num_classes)]
for i, (_, label) in enumerate(dataset.imgs):
labels[label].append(i)
# clustering algorithm to use
deepcluster = clustering.__dict__[args.clustering](args.nmb_cluster)
# training convnet with DeepCluster
for epoch in range(args.start_epoch, args.epochs):
end = time.time()
# remove head
model.top_layer = None
model.classifier = nn.Sequential(
*list(model.classifier.children())[:-1])
# get the features for the whole dataset
features = compute_features(dataloader, model, len(dataset))
# cluster the features
clustering_loss, plot, davg = deepcluster.cluster(features,
verbose=args.verbose)
print davg
if epoch < 20:
plot.savefig(os.path.join(plot_dir, 'e{}'.format(epoch)))
# assign pseudo-labels
train_dataset = clustering.cluster_assign(deepcluster.images_lists,
dataset.imgs)
#for i, image in enumerate(train_dataset):
# save_dir = os.path.join('./viz_emb_start', str(image[1]))
# if not os.path.isdir(save_dir):
# os.makedirs(save_dir)
# imn = (image[0].data.cpu().numpy() * 112) + 112
# imn = np.swapaxes(imn, 0, 2)
# imn = np.swapaxes(imn, 1, 0)
# #print imn.astype('uint8')
# #print imn.astype('uint8').shape
# im = Image.fromarray(imn.astype('uint8'))
# im.save(os.path.join(save_dir, '{}.jpg'.format(i)))
# uniformely sample per target
sampler = UnifLabelSampler(int(args.reassign * len(train_dataset)),
deepcluster.images_lists)
train_dataloader = torch.utils.data.DataLoader(
train_dataset,
batch_size=args.batch,
num_workers=args.workers,
sampler=sampler,
pin_memory=True,
)
# set last fully connected layer
mlp = list(model.classifier.children())
mlp.append(nn.ReLU(inplace=True).cuda())
model.classifier = nn.Sequential(*mlp)
model.top_layer = nn.Linear(fd, len(deepcluster.images_lists))
model.top_layer.weight.data.normal_(0, 0.01)
model.top_layer.bias.data.zero_()
model.top_layer.cuda()
# train network with clusters as pseudo-labels
end = time.time()
loss = train(train_dataloader, model, criterion, optimizer, epoch)
# print log
if args.verbose:
print(
'###### Epoch [{0}] ###### \n'
'Time: {1:.3f} s\n'
'Clustering loss: {2:.3f} \n'
'ConvNet loss: {3:.3f}'.format(epoch,
time.time() - end,
clustering_loss, loss))
nmi_prev = 0
nmi_gt = 0
try:
nmi_prev = normalized_mutual_info_score(
clustering.arrange_clustering(deepcluster.images_lists),
clustering.arrange_clustering(cluster_log.data[-1]))
print('NMI against previous assignment: {0:.3f}'.format(
nmi_prev))
except IndexError:
pass
nmi_gt = normalized_mutual_info_score(
clustering.arrange_clustering(deepcluster.images_lists),
clustering.arrange_clustering(labels))
print('NMI against ground-truth labels: {0:.3f}'.format(nmi_gt))
print('####################### \n')
logs.append([epoch, clustering_loss, loss, nmi_prev, nmi_gt, davg])
# save running checkpoint
if (epoch + 1) % 10 == 0 or epoch == 0:
torch.save(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'optimizer': optimizer.state_dict()
},
os.path.join(args.exp,
'checkpoint_{}.pth.tar'.format(epoch + 1)))
# save cluster assignments
cluster_log.log(deepcluster.images_lists)
scipy.io.savemat(os.path.join(args.exp, 'logs.mat'),
{'logs': np.array(logs)})
def main():
global args
args = parser.parse_args()
# Temporary directory used for downloaded models etc
tmppth = tempfile.mkdtemp()
print('Using temporary directory %s' % tmppth)
#fix random seeds
torch.manual_seed(args.seed)
torch.cuda.manual_seed_all(args.seed)
np.random.seed(args.seed)
best_prec1 = 0
# Checkpoint to be loaded from disc
checkpointbasename = 'checkpoint_%d.pth.tar' % args.timepoint
checkpointfn = os.path.join(tmppth, checkpointbasename)
# Pull model from S3
s3 = boto3.resource('s3')
try:
s3fn = os.path.join(args.checkpointpath, checkpointbasename)
print("Attempting s3 download from %s" % s3fn)
s3.Bucket(args.checkpointbucket).download_file(s3fn, checkpointfn)
except botocore.exceptions.ClientError as e:
if e.response['Error']['Code'] == "404":
print("The object does not exist.")
else:
raise
# Prepare place for output
linearclassfn = os.path.join(
args.linearclasspath,
"linearclass_time_%d_conv_%d" % (args.timepoint, args.conv))
print("Will write output to bucket %s, %s", args.linearclassbucket,
linearclassfn)
# Load model
model = load_model(checkpointfn)
model.cuda()
cudnn.benchmark = True
# Recover disc
os.remove(checkpointfn)
# freeze the features layers
for param in model.features.parameters():
param.requires_grad = False
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
# data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val_in_folders')
valdir_double = os.path.join(args.data, 'val_in_double_folders')
valdir_list = []
# Load in AoA table if needed
if args.aoaval:
aoalist = pd.read_csv('matchingAoA_ImageNet_excel.csv')
for index, row in aoalist.iterrows():
node = row['node']
aoa = float(row['aoa'])
if not math.isnan(aoa):
valdir_list.append({
'node': node,
'pth': os.path.join(valdir_double, node),
'aoa': aoa
})
else:
print('Not found %s' % node)
#valdir_list=valdir_list[:5] trim for testing
print('Using %d validation categories for aoa' % len(valdir_list))
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
if args.tencrops:
transformations_val = [
transforms.Resize(256),
transforms.TenCrop(224),
transforms.Lambda(lambda crops: torch.stack(
[normalize(transforms.ToTensor()(crop)) for crop in crops])),
]
else:
transformations_val = [
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(), normalize
]
transformations_train = [
transforms.Resize(256),
transforms.CenterCrop(256),
transforms.RandomCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(), normalize
]
train_dataset = datasets.ImageFolder(
traindir, transform=transforms.Compose(transformations_train))
val_dataset = datasets.ImageFolder(
valdir, transform=transforms.Compose(transformations_val))
# Load up individual categories for AoA validation
if args.aoaval:
print("Loading individual categories for validation")
val_list_dataset = []
val_list_loader = []
val_list_remap = []
for entry in valdir_list:
val_list_dataset.append(
datasets.ImageFolder(
entry['pth'],
transform=transforms.Compose(transformations_val)))
val_list_loader.append(
torch.utils.data.DataLoader(val_list_dataset[-1],
batch_size=50,
shuffle=False,
num_workers=args.workers))
val_list_remap.append(train_dataset.classes.index(entry['node']))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(val_dataset,
batch_size=int(args.batch_size /
2),
shuffle=False,
num_workers=args.workers)
# logistic regression
print("Setting up regression")
reglog = RegLog(args.conv, len(train_dataset.classes)).cuda()
optimizer = torch.optim.SGD(filter(lambda x: x.requires_grad,
reglog.parameters()),
args.lr,
momentum=args.momentum,
weight_decay=10**args.weight_decay)
# create logs
exp_log = os.path.join(tmppth, 'log')
if not os.path.isdir(exp_log):
os.makedirs(exp_log)
loss_log = Logger(os.path.join(exp_log, 'loss_log'))
prec1_log = Logger(os.path.join(exp_log, 'prec1'))
prec5_log = Logger(os.path.join(exp_log, 'prec5'))
# If savedmodel already exists, load this
print("Looking for saved decoder")
if args.toplayer_epochs:
filename = "model_toplayer_epoch_%d.pth.tar" % (args.toplayer_epochs -
1)
else:
filename = 'model_best.pth.tar'
savedmodelpth = os.path.join(tmppth, filename)
s3_client = boto3.client('s3')
try:
# Try to download desired toplayer_epoch
response = s3_client.download_file(
args.linearclassbucket, os.path.join(linearclassfn, filename),
savedmodelpth)
print('Loading saved decoder %s (s3: %s)' %
(savedmodelpth, os.path.join(linearclassfn, filename)))
model_with_decoder = torch.load(savedmodelpth)
reglog.load_state_dict(model_with_decoder['reglog_state_dict'])
lastepoch = model_with_decoder['epoch']
except:
try:
# Fallback to last saved toplayer_epoch, which we'll use as a starting point
response = s3_client.download_file(
args.linearclassbucket,
os.path.join(linearclassfn, 'model_best.pth.tar'),
savedmodelpth)
print('Loading best-so-far saved decoder %s (s3:%s)' %
(savedmodelpth,
os.path.join(linearclassfn, 'model_best.pth.tar')))
model_with_decoder = torch.load(savedmodelpth)
print('Previous model epoch %d' % model_with_decoder['epoch'])
# But check it isn't greater than desired stage before loading
if model_with_decoder['epoch'] <= args.toplayer_epochs:
lastepoch = model_with_decoder['epoch']
reglog.load_state_dict(model_with_decoder['reglog_state_dict'])
else:
print('Previous model epoch %d was past desired one %d' %
(model_with_decoder['epoch'], args.toplayer_epochs))
lastepoch = 0
except:
lastepoch = 0
print("Will run from epoch %d to epoch %d" %
(lastepoch, args.toplayer_epochs - 1))
for epoch in range(lastepoch, args.toplayer_epochs):
# Top layer epochs
end = time.time()
# train for one epoch
train(train_loader, model, reglog, criterion, optimizer, epoch)
# evaluate on validation set
prec1, prec5, loss = validate(val_loader,
model,
reglog,
criterion,
target_remap=range(1000))
loss_log.log(loss)
prec1_log.log(prec1)
prec5_log.log(prec5)
# remember best prec@1 and save checkpoint
is_best = prec1 > best_prec1
best_prec1 = max(prec1, best_prec1)
filename = 'model_toplayer_epoch_%d.pth.tar' % epoch
modelfn = os.path.join(tmppth, filename)
torch.save(
{
'epoch': epoch + 1,
'arch': 'alexnet',
'state_dict': model.state_dict(),
'reglog_state_dict':
reglog.state_dict(), # Also save decoding layers
'prec5': prec5,
'best_prec1': best_prec1,
'optimizer': optimizer.state_dict(),
},
savedmodelpth)
# Save output to check
s3_client = boto3.client('s3')
response = s3_client.upload_file(savedmodelpth, args.linearclassbucket,
os.path.join(linearclassfn, filename))
for logfile in ['prec1', 'prec5', 'loss_log']:
localfn = os.path.join(tmppth, 'log', logfile)
response = s3_client.upload_file(
localfn, args.linearclassbucket,
os.path.join(linearclassfn, 'log',
"%s_toplayer_epoch_%d" % (logfile, epoch)))
if is_best:
# Save output to check
s3_client = boto3.client('s3')
response = s3_client.upload_file(
savedmodelpth, args.linearclassbucket,
os.path.join(linearclassfn, 'model_best.pth.tar'))
for logfile in ['prec1', 'prec5', 'loss_log']:
localfn = os.path.join(tmppth, 'log', logfile)
response = s3_client.upload_file(
localfn, args.linearclassbucket,
os.path.join(linearclassfn, 'log', logfile))
# Tidy up
for logfile in ['prec1', 'prec5', 'loss_log']:
localfn = os.path.join(tmppth, 'log', logfile)
os.remove(localfn)
os.remove(savedmodelpth)
if args.aoaval:
# Validate individual categories, so loss can be compared to AoA
# # To check weights loaded OK
# # evaluate on validation set
# prec1, prec5, loss = validate(val_loader, model, reglog, criterion)
# loss_log.log(loss)
# prec1_log.log(prec1)
# prec5_log.log(prec5)
aoares = {}
for idx, row in enumerate(
zip(valdir_list, val_list_loader, val_list_remap)):
# evaluate on validation set
print("AOA validation %d/%d" % (idx, len(valdir_list)))
prec1_tmp, prec5_tmp, loss_tmp = validate(row[1],
model,
reglog,
criterion,
target_remap=[row[2]])
aoares[row[0]['node']] = {
'prec1': float(prec1_tmp),
'prec5': float(prec5_tmp),
'loss': float(loss_tmp),
'aoa': row[0]['aoa']
}
# Save to JSON
aoaresultsfn = 'aoaresults_toplayer_epoch_%d.json' % (
args.toplayer_epochs - 1)
aoapth = os.path.join(tmppth, aoaresultsfn)
with open(aoapth, 'w') as f:
json.dump(aoares, f)
response = s3_client.upload_file(
aoapth, args.linearclassbucket,
os.path.join(linearclassfn, aoaresultsfn))
os.remove(aoapth)
# Clean up temporary directories
os.rmdir(exp_log)
os.rmdir(tmppth)
def train(mode: str,
env_params: dict,
ac_params: dict,
rls_params: dict,
pid_params: dict,
results_path: str,
seed=0,
return_logs=True,
save_logs=False,
save_weights=False,
weight_save_interval: int = 10,
save_agents=False,
load_agents=False,
agents_path="",
plot_states=True,
plot_nn_weights=False,
plot_rls=False):
"""
Trains the integrated IDHP agent in the 6DOF environment for a single episode.
:param mode: str indicating what task the agent should perform: train, test_1, or test_2
:param env_params: dict, relevant parameters for environment setup
:param ac_params: dict, relevant parameters for actor-critic setup
:param rls_params: dict, relevant parameters for RLS estimator setup
:param pid_params: relevant parameters for PID setup
:param results_path: Save path for the training logs
:param seed: Random seed for initialization
:param return_logs: Return the logs as function output?
:param save_logs: Save the logs to file?
:param save_weights: Save the weights in the logger? Useful for debugging
:param weight_save_interval: Number of timesteps between saving the neural network weights in the logger
:param save_agents: Save the trained agents to file after training?
:param load_agents: Load pre-trained agents from file before starting the tasks?
:param agents_path: Save or load path for trained agents.
:param plot_states: Plot the states?
:param plot_nn_weights: Plot neural network weights after training? (Warning: takes a while)
:param plot_rls: Plot the RLS estimator gradients after training?
:return: Can return various tuples, depending on above settings
"""
torch.manual_seed(seed)
np.random.seed(seed)
# Environment
env = Helicopter6DOF(dt=env_params['dt'], t_max=env_params['t_max'])
trim_state, trim_actions = env.trim(
trim_speed=env_params['initial_velocity'],
flight_path_angle=env_params['initial_flight_path_angle'],
altitude=env_params['initial_altitude'])
observation = trim_state.copy()
ref = trim_state.copy()
ref_generator = RefGenerator(T=10,
dt=env_params["dt"],
A=10,
u_ref=0,
t_switch=60,
filter_tau=2.5)
# Logging
logger = Logger(params=ac_params)
# Agents:
agent_col = DHPAgent(**ac_params['col'])
agent_lon = DHPAgent(**ac_params['lon'])
if load_agents:
agent_col.load(agents_path + "col.pt")
agent_lon.load(agents_path + "lon.pt")
with open(agents_path + "rls.pkl", 'rb') as f:
rls_estimator = pickle.load(f)
else:
# incremental RLS estimator
rls_estimator = RecursiveLeastSquares(**rls_params)
agents = [agent_col, agent_lon]
# Create controllers
lateral_pid = LatPedPID(phi_trim=trim_state[6],
lat_trim=trim_actions[2],
pedal_trim=trim_actions[3],
dt=env_params["dt"],
gains_dict=pid_params)
collective_pid = CollectivePID6DOF(col_trim=trim_actions[0],
h_ref=env_params['initial_altitude'],
dt=env_params['dt'],
proportional_gain=pid_params['Kh'])
# Excitation signal for the RLS estimator
excitation = np.load('excitation.npy')
# Flags
excitation_phase = False if load_agents else True
update_col = True if load_agents else False
update_lon = True
success = True
rewards = np.zeros(2)
def update_agent(n):
"""
Shorthand to update a single numbered agent after a single transition.
:param n: Index of agent to update, per list 'agents' (0=col, 1=lon)
"""
rewards[n], dr_ds = agents[n].get_reward(next_observation, ref)
F, G = agents[n].get_transition_matrices(rls_estimator)
agents[n].update_networks(observation, next_observation, ref, next_ref,
dr_ds, F, G)
# Main loop
for step in itertools.count():
lateral_cyclic, pedal = lateral_pid(observation)
# TODO: It would be much nicer if reference generation would be an internal thing in the environment I guess
if mode == "train":
if step == 0:
ref_generator.set_task(task="train_lon",
t=0,
obs=observation,
velocity_filter_target=0)
ref = ref_generator.get_ref(observation, env.t)
elif step == 1000:
excitation_phase = False
elif step == env_params['step_switch']:
agent_lon.learning_rate_actor *= 0.1
agent_lon.learning_rate_critic *= 0.1
update_col = True
ref_generator.set_task("train_col",
t=env.t,
obs=observation,
z_start=observation[11])
# Get ref, action, take action
if step < env_params['step_switch']:
actions = np.array([
collective_pid(observation), trim_actions[1] - 0.5 +
agent_lon.get_action(observation, ref), lateral_cyclic,
pedal
])
else:
actions = np.array([
trim_actions[0] - 0.5 +
agent_col.get_action(observation, ref), trim_actions[1] -
0.5 + agent_lon.get_action(observation, ref),
lateral_cyclic, pedal
])
elif mode == "test_1":
if step == 0:
ref_generator.set_task(task="hover", t=0, obs=observation)
ref = ref_generator.get_ref(observation, env.t)
elif step == 500:
ref_generator.set_task("velocity",
t=env.t,
obs=observation,
z_start=0,
velocity_filter_target=25 -
observation[0])
elif step == 2000:
ref_generator.set_task("velocity",
t=env.t,
obs=observation,
z_start=0,
velocity_filter_target=0 -
observation[0])
actions = np.array([
trim_actions[0] - 0.5 + agent_col.get_action(observation, ref),
trim_actions[1] - 0.5 + agent_lon.get_action(observation, ref),
lateral_cyclic, pedal
])
elif mode == "test_2":
if step == 0:
ref_generator.set_task(task="descent",
t=0,
t_switch=0,
obs=observation)
ref = ref_generator.get_ref(observation, env.t)
elif step == 1000:
env.set_engine_status(n_engines_available=1, transient=True)
actions = np.array([
trim_actions[0] - 0.5 + agent_col.get_action(observation, ref),
trim_actions[1] - 0.5 + agent_lon.get_action(observation, ref),
lateral_cyclic, pedal
])
else:
raise NotImplementedError("Training mode unknown. ")
if excitation_phase:
actions += excitation[step]
actions = np.clip(actions, 0, 1)
# Take step in the environment
next_observation, _, done = env.step(actions)
if env.t < 20:
ref_generator.A = 10
elif 20 <= env.t < 40:
ref_generator.A = 15
else:
ref_generator.A = 20
next_ref = ref_generator.get_ref(observation, env.t)
# Update RLS estimator,
rls_estimator.update(observation, actions[:2], next_observation)
# Collective:
if update_col:
update_agent(0)
else:
rewards[0] = 0
# Cyclic
if update_lon:
update_agent(1)
else:
rewards[1] = 0
logger.log_states(env.t, observation, ref, actions, rewards,
env.P_available, env.P_out)
if save_weights and (step % weight_save_interval == 0):
logger.log_weights(env.t, agents, rls_estimator)
if envelope_limits_reached(observation)[0]:
print("Save envelope limits reached, stopping simulation. Seed: " +
str(seed))
print("Cause of violation: " +
envelope_limits_reached(observation)[1])
success = False
done = True
if np.isnan(actions).any():
print("NaN encounted in actions at timestep", step, " -- ",
actions, "Seed: " + str(seed))
success = False
done = True
if done or (mode == "test_2" and observation[11] > 0):
break
# Next step..
observation = next_observation
ref = next_ref
step += 1
# print("Training time: ", time.time()-t_start)
logger.finalize()
if save_logs:
if not os.path.exists(results_path):
os.mkdir(results_path)
logger.save(path=results_path + "log.pkl")
if save_agents:
if not os.path.exists(agents_path):
os.mkdir(agents_path)
agent_col.save(path=agents_path + "col.pt")
agent_lon.save(path=agents_path + "lon.pt")
rls_estimator.save(path=agents_path + "rls.pkl")
# Visualization
if plot_states:
plot_stats(logger)
if plot_nn_weights and save_weights:
plot_neural_network_weights(logger,
figsize=(8, 6),
agent_name='col',
title='Collective')
plot_neural_network_weights(logger,
figsize=(8, 6),
agent_name='lon',
title='Longitudinal Cyclic')
elif plot_nn_weights and not save_weights:
print(
"Called plot_nn_weights but no weights were saved (save_weights=False), skipping. "
)
if plot_rls and save_weights:
plot_rls_weights(logger)
elif plot_rls and not save_weights:
print(
"Called plot_rls_weights but no weights were saved (save_weights=False), skipping. "
)
score = np.sqrt(-logger.state_history.iloc[5000:6000]['r2'].sum() / 1000)
if return_logs:
return logger, score
else:
if success:
return 1, score
else:
return 0, 0
