A. Dice Tower

本文介绍了一种通过观察部分骰子面数值来唯一确定整个由多个骰子堆叠成的塔面上所有数值的方法。该方法利用了骰子对面数字之和为7的特点,通过检查侧面可见数字是否包含顶部数字及其对面数字来判断是否可以唯一确定。

time limit per test
2 seconds
memory limit per test
256 megabytes
input
standard input
output
standard output

A dice is a cube, its faces contain distinct integers from 1 to 6 as black points. The sum of numbers at the opposite dice faces always equals 7. Please note that there are only two dice (these dices are mirror of each other) that satisfy the given constraints (both of them are shown on the picture on the left).

Alice and Bob play dice. Alice has built a tower from n dice. We know that in this tower the adjacent dice contact with faces with distinct numbers. Bob wants to uniquely identify the numbers written on the faces of all dice, from which the tower is built. Unfortunately, Bob is looking at the tower from the face, and so he does not see all the numbers on the faces. Bob sees the number on the top of the tower and the numbers on the two adjacent sides (on the right side of the picture shown what Bob sees).

Help Bob, tell whether it is possible to uniquely identify the numbers on the faces of all the dice in the tower, or not.

Input

The first line contains a single integer n (1 ≤ n ≤ 100) — the number of dice in the tower.

The second line contains an integer x (1 ≤ x ≤ 6) — the number Bob sees at the top of the tower. Next n lines contain two space-separated integers each: the i-th line contains numbers ai, bi (1 ≤ ai, bi ≤ 6; ai ≠ bi) — the numbers Bob sees on the two sidelong faces of the i-th dice in the tower.

Consider the dice in the tower indexed from top to bottom from 1 to n. That is, the topmost dice has index 1 (the dice whose top face Bob can see). It is guaranteed that it is possible to make a dice tower that will look as described in the input.

Output

Print "YES" (without the quotes), if it is possible to to uniquely identify the numbers on the faces of all the dice in the tower. If it is impossible, print "NO" (without the quotes).

Sample test(s)
input
3
6
3 2
5 4
2 4
output
YES
input
3
3
2 6
4 1
5 3
output
NO


解题说明:此题的意思是通过给你的这些数推断出筛子每一面的数字,由于题目中交代拼接在一起的两个面数字不能相同,并且告诉了顶面的数字。为了能推断出所有面,必须保证水平面拼接部分的数要么等于顶面的数字,要么等于其相对的数字,只有这样才能够使用拼接的两个面数字相斥的原理。这样想以后,只需要保证外面一圈的数字不含顶面数字和其相对数字即可。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;

int main()
{
	int n,x,i;
	int flag;
	int a[101],b[101];
	flag=true;
	scanf("%d",&n);
	scanf("%d",&x);
	for(i=0;i<n;i++)
	{
		scanf("%d %d",&a[i],&b[i]);
		if(a[i]==x||a[i]==7-x)
		{
			flag=false;
		}
		if(b[i]==x||b[i]==7-x)
		{
			flag=false;
		}
	}
	if(flag==true)
	{
		printf("YES\n");
	}
	else
	{
		printf("NO\n");
	}
	return 0;
}



修改下面程序的参数以此进行GPU显存的优化:# -------------------------------------------------------- # LISA: Reasoning Segmentation via Large Language Model # Licensed under Apache-2.0 license [see LICENSE for details] # Authors: Xin Lai, Zhuotao Tian, Yukang Chen, Yanwei Li, Yuhui Yuan, Shu Liu, Jiaya Jia # -------------------------------------------------------- # GSVA: Generalized Segmentation via Multimodal Large Language Models # Modified by Zhuofan Xia # -------------------------------------------------------- import argparse import os os.environ["HF_ENDPOINT"] = "https://hf-mirror.com" import shutil from functools import partial import torch import transformers import deepspeed import deepspeed.comm as dist from torch.utils.data import DataLoader, DistributedSampler from tqdm import tqdm import model.llava.conversation as conversation_lib from model import LisaGSVAForCausalLM, add_task_tokens, init_vision_seg_for_model from data import MixedTrainingDataset, ValDataset, collate_fn from solver import train_one_epoch, validate, eval_gres from utils import get_logger def parse_args(): # parser.add_argument("--dataset_dir", required=True, type=str, help="Where do we store the huge datasets?") # parser.add_argument("--dataset", default="sem_seg||refer_seg||vqa||reason_seg", type=str) # parser.add_argument("--sem_seg_data",default="ade20k||cocostuff||pascal_part||paco_lvis||mapillary",type=str) # parser.add_argument("--refer_seg_data", default="refclef||refcoco||refcoco+||refcocog", type=str) # parser.add_argument("--image_size", default=1024, type=int, help="Image size of segmentation model.") # parser.add_argument("--lora_alpha", default=16, type=int) parser = argparse.ArgumentParser(description="GSVA Training and Evaluation") parser.add_argument("--segmentation_model_path", default="pretrain_weights_sam/sam_vit_h_4b8939.pth", type=str) parser.add_argument("--vision-tower", default="openai/clip-vit-large-patch14", type=str) parser.add_argument("--local_rank", default=0, type=int, help="For local rank in distributed training") # parser.add_argument("--mllm_model_path", default="liuhaotian/llava-llama-2-13b-chat-lightning-preview") parser.add_argument("--mllm_model_path", default="pretrain_weights_llava") parser.add_argument("--dataset_dir", default="dataset", type=str, help="Where do we store the huge datasets?") parser.add_argument("--precision", default="bf16", type=str, choices=["fp32", "bf16", "fp16"], help="precision for training and inference") parser.add_argument("--image_size", default=128, type=int, help="Image size of segmentation model.") parser.add_argument("--model_max_length", default=1024, type=int) parser.add_argument("--lora_r", default=1, type=int) parser.add_argument("--dataset", default="refer_seg", type=str) parser.add_argument("--sample_rates", default="9,3,3,1", type=str) parser.add_argument("--sem_seg_data", default="ade20k", type=str, ) parser.add_argument("--refer_seg_data", default="refcocog", type=str) parser.add_argument("--vqa_data", default="llava_instruct_150k", type=str) parser.add_argument("--reason_seg_data", default="ReasonSeg|train", type=str) parser.add_argument("--val_dataset", default="ReasonSeg|val", type=str) parser.add_argument("--log_base_dir", default="./outputs", type=str) parser.add_argument("--exp_name", default="default", type=str) parser.add_argument("--epochs", default=10, type=int) parser.add_argument("--steps_per_epoch", default=500, type=int) # parser.add_argument("--batch_size", default=16, type=int, help="batch size per device per step") parser.add_argument("--batch_size", default=1, type=int, help="batch size per device per step") parser.add_argument("--grad_accumulation_steps", default=1, type=int) parser.add_argument("--val_batch_size", default=1, type=int) parser.add_argument("--workers", default=8, type=int) parser.add_argument("--lr", default=0.0003, type=float) parser.add_argument("--ce_loss_weight", default=1.0, type=float) parser.add_argument("--dice_loss_weight", default=0.5, type=float) parser.add_argument("--bce_loss_weight", default=2.0, type=float) parser.add_argument("--lora_alpha", default=1, type=int) parser.add_argument("--lora_dropout", default=0.05, type=float) parser.add_argument("--lora_target_modules", default="q_proj,v_proj", type=str) parser.add_argument("--explanatory", default=0.1, type=float) parser.add_argument("--beta1", default=0.9, type=float) parser.add_argument("--beta2", default=0.95, type=float) parser.add_argument("--num_classes_per_sample", default=2, type=int) parser.add_argument("--exclude_val", action="store_true", default=False) parser.add_argument("--no_eval", action="store_true", default=False) parser.add_argument("--eval_only", action="store_true", default=False) parser.add_argument("--out_dim", default=256, type=int) parser.add_argument("--resume", default="", type=str) parser.add_argument("--print_freq", default=1, type=int) parser.add_argument("--start_epoch", default=0, type=int) parser.add_argument("--train_mask_decoder", action="store_true", default=True) parser.add_argument("--use_mm_start_end", action="store_true", default=True) parser.add_argument("--auto_resume", action="store_true", default=False, help='Whether resume the latest checkpoint when training is interrupted.') parser.add_argument("--no_sampling", action="store_true", default=False, help="Only one dataset finetuning, train on full length dataset.") parser.add_argument('--val_refzom', action='store_true', default=False, help='Default gres/zom evaluation, if True, RefZOM, else gRefCOCO.') parser.add_argument("--conv_type",default="llava_v1", type=str, choices=["llava_v1", "llava_llama_2"],) parser.add_argument("--merge_lora_path", type=str, default=None, help="Path to destination HF checkpoint.") parser.add_argument("--weight", type=str, default=None, help="Path to a bin ckpt.") parser = deepspeed.add_config_arguments(parser) return parser.parse_args() def main(): # Get arguments from commandline args = parse_args() # Set up Deepspeed distributed environment torch.cuda.set_device(args.local_rank) dist.init_distributed() args.world_size = world_size = dist.get_world_size() args.rank = rank = dist.get_rank() local_rank: int args.local_rank = local_rank = dist.get_local_rank() # Set up logging dir args.log_dir = os.path.join(args.log_base_dir, args.exp_name) if rank == 0: os.makedirs(args.log_dir, exist_ok=True) logger = get_logger(args.log_dir, rank, name=args.exp_name) # Create model tokenizer = transformers.AutoTokenizer.from_pretrained( args.mllm_model_path, cache_dir=None, model_max_length=args.model_max_length, padding_side="right", use_fast=False ) tokenizer, args = add_task_tokens(tokenizer, args) # Determine working model precision args.torch_dtype = torch.float32 if args.precision == "bf16": args.torch_dtype = torch.bfloat16 elif args.precision == "fp16": args.torch_dtype = torch.half # Prepare model creation arguments model_args = { "train_mask_decoder": args.train_mask_decoder, "out_dim": args.out_dim, "ce_loss_weight": args.ce_loss_weight, "dice_loss_weight": args.dice_loss_weight, "bce_loss_weight": args.bce_loss_weight, "seg_token_idx": args.seg_token_idx, "segmentation_model_path": args.segmentation_model_path, "vision_tower": args.vision_tower, "use_mm_start_end": args.use_mm_start_end, "tokenizer": tokenizer, "rej_token_idx": args.rej_token_idx } model = LisaGSVAForCausalLM.from_pretrained( args.mllm_model_path, torch_dtype=args.torch_dtype, **model_args ) # Set up two vision models for whole model, and lora model = init_vision_seg_for_model(model, tokenizer, args).half() # Evaluation or finetuning, btw, merge-lora always fails if args.weight is not None: # `args.weight`` is a large `*.bin` file. state_dict = torch.load(args.weight, map_location="cpu", weights_only=True) model.load_state_dict(state_dict, strict=False) logger.info("Load trained weights successfully!") # Specify the conversation type conversation_lib.default_conversation = conversation_lib.conv_templates[args.conv_type] # Build training set if args.eval_only: train_dataset = None else: train_dataset = MixedTrainingDataset( args.dataset_dir, tokenizer, args.vision_tower, samples_per_epoch=args.batch_size * args.grad_accumulation_steps * args.steps_per_epoch * world_size, precision=args.precision, image_size=args.image_size, num_classes_per_sample=args.num_classes_per_sample, exclude_val=args.exclude_val, dataset=args.dataset, sample_rate=[float(x) for x in args.sample_rates.split(",")], sem_seg_data=args.sem_seg_data, refer_seg_data=args.refer_seg_data, vqa_data=args.vqa_data, reason_seg_data=args.reason_seg_data, explanatory=args.explanatory, no_sampling=args.no_sampling ) if args.no_eval: val_dataset = None logger.info(f"Training with {len(train_dataset)} examples.") else: val_dataset = ValDataset( args.dataset_dir, tokenizer, args.vision_tower, args.val_dataset, args.image_size ) grefcoco_val_ds = ValDataset( args.dataset_dir, tokenizer, args.vision_tower, 'refzom|final|test' if args.val_refzom else 'grefcoco|unc|val', args.image_size ) if args.eval_only: logger.info(f"Testing with {len(val_dataset)} examples.") else: logger.info(f"Training with {len(train_dataset)} examples and validating with {len(val_dataset)} examples, also validating on gRefCOCO with {len(grefcoco_val_ds)} examples.") # The accelerated training configurations only work for ZeRO-2. if args.eval_only: ds_config = { "train_micro_batch_size_per_gpu": 1, "fp16": { "enabled": args.precision == "fp16", }, "bf16": { "enabled": args.precision == "bf16", } } else: ds_config = { "train_micro_batch_size_per_gpu": args.batch_size, "gradient_accumulation_steps": args.grad_accumulation_steps, "optimizer": { "type": "Adam", "params": { "lr": args.lr, "weight_decay": 0.0, "betas": (args.beta1, args.beta2), }, }, "scheduler": { "type": "WarmupDecayLR", "params": { "total_num_steps": args.epochs * args.steps_per_epoch, "warmup_min_lr": 0, "warmup_max_lr": args.lr, "warmup_num_steps": 100, "warmup_type": "linear", }, }, "fp16": { "enabled": args.precision == "fp16", }, "bf16": { "enabled": args.precision == "bf16", }, "gradient_clipping": 1.0, "zero_optimization": { "stage": 2, "contiguous_gradients": True, "overlap_comm": True, "reduce_scatter": True, "reduce_bucket_size": 1e9, "allgather_bucket_size": 1e9 } } # Build a model engine wrapped with Deepspeed if args.eval_only: model_engine, optimizer, train_loader, scheduler = deepspeed.initialize( model=model, config=ds_config ) else: logger.info('Before initializing deepspeed zero optimizer...') model_engine, optimizer, train_loader, scheduler = deepspeed.initialize( model=model, model_parameters=model.parameters(), training_data=train_dataset, collate_fn=partial( collate_fn, tokenizer=tokenizer, conv_type=args.conv_type, use_mm_start_end=args.use_mm_start_end, local_rank=local_rank, ), config=ds_config ) train_loader.num_local_io_workers = args.workers logger.info('After initializing deepspeed zero optimizer!') # resume deepspeed checkpoint, `auto-resume` snippets are borrowed from Swin Transfomer codebase: # https://github.com/microsoft/Swin-Transformer/blob/f82860bfb5225915aca09c3227159ee9e1df874d/utils.py#L163 if args.auto_resume: checkpoints = os.listdir(args.log_dir) checkpoints = [ckpt for ckpt in checkpoints if ckpt.startswith('ckpt_model')] if len(checkpoints) > 0: args.resume = max([os.path.join(args.log_dir, d) for d in checkpoints], key=os.path.getmtime) logger.info(f"Auto resume found latest: {args.resume}") else: logger.info("No auto resume.") if args.resume: # resume from training, scattered checkpoints (list of ***.pt) load_path, client_state = model_engine.load_checkpoint(args.resume) with open(os.path.join(args.resume, "latest"), "r") as f: ckpt_dir = f.readlines()[0].strip() args.start_epoch = ( int(ckpt_dir.replace("global_step", "")) // args.steps_per_epoch ) logger.info( "resume training from {}, start from epoch {}".format( args.resume, args.start_epoch ) ) # Build validation dataset if val_dataset is not None: assert args.val_batch_size == 1 val_sampler = DistributedSampler(val_dataset, shuffle=False, drop_last=False) val_loader = DataLoader( val_dataset, batch_size=args.val_batch_size, shuffle=False, num_workers=args.workers, pin_memory=False, sampler=val_sampler, collate_fn=partial( collate_fn, tokenizer=tokenizer, conv_type=args.conv_type, use_mm_start_end=args.use_mm_start_end, local_rank=local_rank ) ) if val_dataset.ds not in ['grefcoco', 'refzom']: grefcoco_sampler = DistributedSampler(grefcoco_val_ds, shuffle=False, drop_last=False) grefcoco_loader = DataLoader( grefcoco_val_ds, batch_size=args.val_batch_size, shuffle=False, num_workers=args.workers, pin_memory=False, sampler=grefcoco_sampler, collate_fn=partial( collate_fn, tokenizer=tokenizer, conv_type=args.conv_type, use_mm_start_end=args.use_mm_start_end, local_rank=local_rank ) ) else: grefcoco_loader = None # If we only want to evaluate models, then we evaluate them and quit the program. if args.eval_only: if val_dataset.ds in ['grefcoco', 'refzom']: eval_gres(val_loader, model_engine, 0, args, logger) else: validate(val_loader, model_engine, 0, args, logger) return # Otherwise, we train the model using the initialized Deepspeed-Zero model engine. logger.info("Training begin!") train_iter = iter(train_loader) for epoch in tqdm(range(args.start_epoch, args.epochs), desc="train:"): # train for one epoch, keep a `train_iter`` for iter-based training train_iter = train_one_epoch(train_loader, model_engine, epoch, train_iter, args, logger) # barrier for saving checkpoints dist.barrier() save_dir = os.path.join(args.log_dir, f"ckpt_model_{epoch + 1:02d}") if rank == 0 and os.path.exists(save_dir): shutil.rmtree(save_dir) model_engine.save_checkpoint(save_dir) dist.barrier() # Skip if we don't need evalutation if args.no_eval: continue else: reason_giou, reason_ciou = validate(val_loader, model_engine, epoch, args, logger) grefcoco_giou, grefcoco_ciou, n_acc, t_acc = eval_gres(grefcoco_loader, model_engine, epoch, args, logger) if rank == 0: with open(os.path.join(args.log_dir, "quick_look_result.log"), "a") as t: t.write( f"[{epoch + 1}] reasonseg_val: gIoU:{reason_giou:.4f}, cIoU:{reason_ciou:.4f}, " f"grefcoco_val: gIoU:{grefcoco_giou:.4f}, cIoU:{grefcoco_ciou:.4f}, NAcc:{n_acc:.4f}, TAcc:{t_acc:.4f}.\n" ) if __name__ == "__main__": main()
09-01
<think>好的,我现在需要处理用户关于torchmetrics.Dice参数和使用方法的问题。首先,我得回忆一下自己对这个模块的了解。TorchMetrics是PyTorch的一个指标库,方便在训练过程中计算各种评估指标。Dice系数在医学图像分割中很常用,用来衡量两个样本的相似度。用户的问题具体是参数说明和使用方法。我需要先查阅一下官方文档或者源代码,确认Dice类的参数。记得Dice有几个重要的参数,比如num_classes、average、ignore_index等。可能还有是否multiclass的选项。需要把这些参数列出来,并逐一解释每个参数的作用和可能的取值。然后,使用方法部分,用户可能需要一个代码示例。根据引用中的例子,比如用户之前提到的Accuracy的使用,Dice的使用应该类似。需要导入torchmetrics中的Dice,初始化实例,然后在每个batch中更新,最后计算并重置。要注意是否需要处理二分类还是多分类的情况,可能需要调整参数。比如,如果是二分类,可能需要设置multiclass=False,或者调整num_classes的值。另外,用户提供的引用里有提到Dice作为评估指标,在医学图像分割中的应用,所以可能需要强调在分割任务中的使用场景。比如,输入应该是预测的分割logits或概率,以及目标标签。需要注意输入的形状,比如是否要经过sigmoid或softmax处理,或者是否需要将类别维度分开。还要考虑可能的错误,比如用户可能混淆了DiceDiceLoss,需要指出Dice指标和损失函数的区别。不过用户的问题明确是关于torchmetrics中的Dice类,所以应该集中在指标计算上。 接下来,需要组织回答的结构。先介绍Dice系数的作用,然后参数说明,再给出使用步骤和代码示例。代码部分需要包括初始化metric,更新每个batch,计算总体结果,最后重置。可能还需要提到device的处理,比如将数据和模型放到GPU时,metric是否也需要移动,或者是否自动处理。另外,需要检查参数是否有默认值,比如average参数默认是macro还是micro,或者是否有其他选项。例如,对于多分类问题,average参数可能控制如何平均各个类别的Dice系数。ignore_index可能用于排除某些背景类别的计算。 在代码示例中,可能需要生成预测和目标张量,比如二分类的情况,输入是logits,经过sigmoid后转为概率,然后与目标比较。或者多分类时,使用argmax得到预测类别。不过Dice的计算可能直接接受logits,或者需要先经过激活函数。需要确认torchmetrics.Dice的处理方式,是否需要用户自己处理logits,或者是否内部有处理。 比如,根据文档,Dice类的输入应该是预测的概率或logits,以及目标的整数标签。对于多分类,可能需要设置multiclass=True,并指定num_classes。如果二分类,可能需要设置multiclass=False,此时将预测视为二值化的概率,通过阈值处理。可能还需要注意输入的形状,比如对于二维分割任务,输入可能是(batch_size, num_classes,height,width)或者(batch_size, height, width),具体取决于是否是多分类。需要举例说明不同的情况如何处理。 此外,引用中的第三个提到了Dice系数在2D图像中的应用,所以示例可以基于2D的情况,比如医学图像分割。在代码中,可以模拟一个batch的数据,展示如何计算每个batch和整体的Dice系数。 最后,生成相关问题,可能涉及Dice系数的意义、与其他指标的对比、多分类中的参数调整,或者如何与损失函数结合使用。需要确保问题与用户当前的问题相关,并引导进一步学习。</think>### TorchMetrics.Dice 参数说明及使用方法 #### 一、Dice 系数简介 Dice 系数(Dice Coefficient)是医学图像分割任务中常用的评估指标,用于衡量预测结果与真实标签的相似度,公式为: $$Dice = \frac{2|A \cap B|}{|A| + |B|}$$ 其中 $A$ 为预测区域,$B$ 为真实区域[^3]。 --- #### 二、`torchmetrics.Dice` 参数详解 | 参数 | 类型 | 默认值 | 说明 | |------|------|--------|------| | `num_classes` | int | None | 分类任务中的类别总数(多分类时必填) | | `average` | str | "micro" | 聚合方式:`"micro"`(整体统计)、`"macro""(各类别平均)、`"weighted"`(加权平均) | | `ignore_index` | int | None | 忽略指定类别的计算(常用于排除背景) | | `multiclass` | bool | False | 是否为多分类任务(二分类时设为 False) | | `threshold` | float | 0.5 | 二分类预测的阈值(仅当 `multiclass=False` 时生效) | --- #### 三、使用步骤(以医学图像分割为例) 1. **初始化 Dice 指标** ```python import torch import torchmetrics # 二分类任务(如肿瘤分割) dice_metric = torchmetrics.Dice( multiclass=False, threshold=0.5 # 预测概率 >0.5 视为阳性 ) # 多分类任务(如器官分割) dice_metric = torchmetrics.Dice( num_classes=3, # 假设包含背景、器官A、器官B average="macro", ignore_index=0 # 忽略背景类 ) ``` 2. **逐批次更新指标** ```python # 模拟一个验证批次 preds = torch.sigmoid(model(input_data)) # 二分类预测概率 [B, H, W] targets = targets.long() # 真实标签 [B, H, W] # 更新指标状态 dice_metric.update(preds, targets) ``` 3. **计算全局指标** ```python total_dice = dice_metric.compute() print(f"Dice Score: {total_dice:.4f}") ``` 4. **重置指标状态** ```python dice_metric.reset() # 准备下一轮验证 ``` --- #### 四、注意事项 1. **输入格式**:预测值需为概率值(通过 `sigmoid`/`softmax` 处理后的输出),目标值需为整数标签 2. **设备同步**:若使用 GPU,需确保指标与数据在同一设备: ```python dice_metric = dice_metric.to(device) ``` 3. **与损失函数区别**:`Dice` 是评估指标,若需作为损失函数应使用 `torch.nn.DiceLoss`[^3] ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值