def flower(n_points, petals, petal_length, petal_width, seed): #plant the flower seed random.seed(seed) flowerpoints = np.zeros([n_points, 2]) flowerlabels = np.zeros([n_points]) for p in range(n_points): petal = random.randint(0, petals) flowerlabels[p] = petal #find center if petal == 0: center = np.array([.5, .5]) else: angle0 = (petal - 1) / (petals - 1) * 2 * math.pi radius0 = petal_length * random.random() center = np.array([.5, .5]) + angletocoords2d(angle0, radius0) angle1 = 2 * math.pi * random.random() if petal == 0: radius1 = petal_width * random.random( ) / 2 #2 * petal_width * random.random() else: radius1 = petal_width * random.random() * ( .75 + -abs(radius0 / petal_length - .75)) translation = angletocoords2d(angle1, radius1) flowerpoints[p, :] = center + translation return torch.tensor(flowerpoints, dtype=torch.float), torch.tensor(flowerlabels, dtype=torch.int)
def grid(n_points, n_lines, seed): random.seed(seed) n_pointsonaline = int(n_points / n_lines) grid_points = np.zeros([n_points, 2]) grid_labels = np.zeros([n_points]) for x in range(n_lines): for y in range(n_pointsonaline): angle1 = 2 * math.pi * random.random() radius1 = random.random() / n_lines grid_points[x * n_pointsonaline + y, :] = np.array([ x / n_lines, y / n_pointsonaline ]) + angletocoords2d(angle1, radius1) / n_pointsonaline return torch.tensor(grid_points, dtype=torch.float), torch.tensor(grid_labels, dtype=torch.int)
def circle(n_points, width, seed=0): random.seed(seed) circlepoints = np.zeros([n_points, 2]) for k in range(n_points): angle = 2 * math.pi * k / n_points radius = 1 angle_sway = random.random() * 2 * math.pi radius_sway = width * random.random() center = angletocoords2d(angle, radius) translation = angletocoords2d(angle_sway, radius_sway) circlepoints[k, :] = (center + translation) / 2 + 0.5 return torch.tensor(circlepoints, dtype=torch.float)
def simplexflower(n_points, dim, var, seed=0): random.seed(seed) n_points = n_points - n_points % dim single_num = int(n_points / dim) simflpoints = [] for i in range(dim): mean = np.zeros(dim) mean[i] = 0.5 cov = np.identity(dim) * var cov[i, i] = 0.1 points = np.random.multivariate_normal(mean, cov, single_num) simflpoints.append(points) simflpoints = np.vstack(simflpoints) return torch.tensor(simflpoints, dtype=torch.float)
def gaussimplex(n_points, dim, var, seed=0): random.seed(seed) n_points = n_points - n_points % dim single_num = int(n_points / dim) simplexpoints = [] mean = np.zeros(dim) cov = np.identity(dim) * var for i in range(dim): v = np.zeros(dim) v[i] = 1 points = np.random.multivariate_normal(mean, cov, single_num) + v simplexpoints.append(points) simplexpoints = np.vstack(simplexpoints) return torch.tensor(simplexpoints, dtype=torch.float)
def gaussflower(n_points, petals, seed=0): random.seed(seed) n_points = n_points - n_points % petals gausspoints = [] single_num = int(n_points / petals) for i in range(petals): points = rotate2d( 2 * math.pi * i / petals, np.random.multivariate_normal([3, 0], [[1, 0], [0, 1 / (10 * petals)]], single_num)) gausspoints.append(points) gausspoints = np.vstack(gausspoints) return torch.tensor(gausspoints, dtype=torch.float)
def snail(n_points, bend, width, dim, seed=0): random.seed(seed) snailpoints = np.zeros([n_points, dim]) for k in range(n_points): angle = bend * 2 * math.pi * k / n_points radius = ((n_points - k) / n_points) * 10 angle_sway = random.random() radius_sway = width * random.random() center = np.random.uniform(-1, 1, dim) center[:2] = angletocoords2d(angle, radius) #center = angletocoords2d(angle, radius) translation = np.zeros(dim) translation[:2] = angletocoords2d(angle_sway, radius_sway) #translation = angletocoords2d(angle_sway, radius_sway) snailpoints[k, :] = (center + translation) / 2 + 0.5 return torch.tensor(snailpoints, dtype=torch.float)
def spheresimplex(n_points, dim, rad, seed=0): random.seed(seed) n_points = n_points - n_points % dim single_num = int(n_points / dim) simplexpoints = [] mean = np.zeros(dim) cov = np.identity(dim) for i in range(dim): v = np.zeros(dim) v[i] = 1 points = np.random.multivariate_normal(mean, cov, single_num) norm = np.linalg.norm(points, axis=1) points = (points / norm[:, np.newaxis]) * rad + v simplexpoints.append(points) simplexpoints = np.vstack(simplexpoints) return torch.tensor(simplexpoints, dtype=torch.float)
def disc(n_points, width, seed=0): random.seed(seed) discpoints = np.zeros([n_points, 2]) for k in range(n_points): if k % 2 == 0: angle = 2 * math.pi * k / n_points radius = 1 angle_sway = random.random() * 2 * math.pi radius_sway = width * random.random() center = angletocoords2d(angle, radius) translation = angletocoords2d(angle_sway, radius_sway) discpoints[k, :] = (center + translation) / 2 + 0.5 else: angle = random.random() * 2 * math.pi radius = math.sqrt(random.random()) center = angletocoords2d(angle, radius) discpoints[k, :] = center / 2 + 0.5 return torch.tensor(discpoints, dtype=torch.float)
def train(train_loader, model, optimizer, epoch, args, task, metric_meter=None, scheduler=None, summary_logger=None): # calc batch time batch_time = utils.AverageMeter() # reset metric_meter metric_meter.reset() steps_per_epoch = len(train_loader) # switch to train mode model.train() end = time.time() for step_inbatch, batch in enumerate(train_loader): # select model inputs inputs = task.select_model_inputs(batch) # forward pass outputs = model(**inputs) # get loss and logits loss = outputs[0] logits = outputs[1] # schedule learning rate if scheduler is not None: scheduler.step() # backward pass optimizer.zero_grad() loss.backward() optimizer.step() # get predictions if task.logit_to_id and isinstance(logits, torch.Tensor): predictions = utils.get_ids_from_logits(logits.clone()) elif isinstance(logits, torch.Tensor): predictions = logits.clone() else: predictions = logits global_step = epoch * steps_per_epoch + step_inbatch if global_step % args.print_freq == 0: with torch.no_grad(): batch_time.update((time.time() - end) / args.print_freq) end = time.time() # update metrics metric_meter.update_scores("loss", { 'score': loss.cpu().numpy(), 'count': 1 }) if isinstance(predictions, torch.Tensor): predictions = predictions.cpu().numpy() gathered_dict = { k: v.cpu().numpy() if torch.is_tensor(v) else v for k, v in batch.items() } gathered_dict['predictions'] = predictions metric_meter.update_metrics(gathered_dict) average_scores = metric_meter.get_average_scores() if args.distributed: average_scores = { k: { 'score': reduce_sum_tensor( torch.tensor(v['score'] * v['count'], device='cuda')).cpu().numpy(), 'count': reduce_sum_tensor( torch.tensor(v['count'], device='cuda')).cpu().numpy() } for k, v in average_scores.items() } average_scores = { k: { 'score': v['score'] / v['count'], 'count': v['count'] } for k, v in average_scores.items() } if args.local_rank == 0 or not args.distributed: score_log = summary_logger(average_scores, global_step, args.task, "train") logging.info( '-----Training----- \nEpoch: [{0}][{1}/{2}]\t' 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' 'Speed {3:.3f} ({4:.3f})\t'.format( epoch, step_inbatch, steps_per_epoch, args.batch_size / batch_time.val, args.batch_size / batch_time.avg, batch_time=batch_time) + score_log)
def validate(eval_loader, model, epoch, args, task, metric_meter): batch_time = utils.AverageMeter() # reset metric_meter metric_meter.reset() # switch to evaluate mode model.eval() with torch.no_grad(): end = time.time() for step_inbatch, batch in enumerate(eval_loader): # select model inputs inputs = task.select_model_inputs(batch) # forward pass outputs = model(**inputs) # get loss and logits loss = outputs[0] logits = outputs[1] # get predictions if task.logit_to_id and isinstance(logits, torch.Tensor): predictions = utils.get_ids_from_logits(logits.clone()) elif isinstance(logits, torch.Tensor): predictions = logits.clone() else: predictions = logits # update metrics metric_meter.update_scores("loss", { 'score': loss.cpu().numpy(), 'count': 1 }) if isinstance(predictions, torch.Tensor): predictions = predictions.cpu().numpy() gathered_dict = { k: v.cpu().numpy() if torch.is_tensor(v) else v for k, v in batch.items() } gathered_dict['predictions'] = predictions metric_meter.update_metrics(gathered_dict) # reduce average scores average_scores = metric_meter.get_average_scores() if args.distributed: average_scores = { k: { 'score': reduce_sum_tensor( torch.tensor(v['score'] * v['count'], device='cuda')).cpu().numpy(), 'count': reduce_sum_tensor( torch.tensor(v['count'], device='cuda')).cpu().numpy() } for k, v in average_scores.items() } average_scores = { k: { 'score': v['score'] / v['count'], 'count': v['count'] } for k, v in average_scores.items() } if step_inbatch % args.print_freq == 0: batch_time.update((time.time() - end) / args.print_freq) end = time.time() if args.local_rank == 0 or not args.distributed: score_log = metric_meter.get_score_str( "eval", average_scores=average_scores) logging.info( '-----Evaluation----- \nEpoch: [{0}][{1}/{2}]\t' 'Time {batch_time.val:.3f} ({batch_time.avg:.3f})\t' 'Speed {3:.3f} ({4:.3f})\t'.format( epoch, step_inbatch, len(eval_loader), args.batch_size / batch_time.val, args.batch_size / batch_time.avg, batch_time=batch_time) + score_log) # recude final scores average_scores = metric_meter.get_average_scores() if args.distributed: average_scores = { k: { 'score': reduce_sum_tensor( torch.tensor(v['score'] * v['count'], device='cuda')).cpu().numpy(), 'count': reduce_sum_tensor(torch.tensor(v['count'], device='cuda')).cpu().numpy() } for k, v in average_scores.items() } average_scores = { k: { 'score': v['score'] / v['count'], 'count': v['count'] } for k, v in average_scores.items() } if args.local_rank == 0 or not args.distributed: metric_meter.reset() metric_meter.set_average_scores(average_scores) score_log = metric_meter.get_score_str("eval", average_scores=average_scores) logging.info('-----Evaluation-----\n' + score_log) return metric_meter