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