def bert_base_adamw_llrd(model):# 定义一个函数，用于创建基于BERT模型和AdamW优化算法的优化器对象，并设置学习率衰减策略 
    """
    该函数用于创建基于BERT模型和AdamW优化算法的优化器对象，并设置学习率衰减策略。

    Args:
        model: 需要进行优化的模型对象。

    Returns:
        创建好的AdamW优化器对象。
    """
    
    opt_parameters = []# 定义一个空列表，用于存储优化器需要更新的参数及其对应设置
    named_parameters = list(model.named_parameters())  # 获取模型中所有命名参数（即参数名和参数值）并转换为列表 

    no_decay = ["bias", "LayerNorm.bias", "LayerNorm.weight"]# 定义一个列表，包含不需要进行权重衰减操作的参数名后缀 
    init_lr = 3.5e-6 
    head_lr = 3.6e-6
    lr = init_lr
    # 从命名参数中筛选出包含"pooler"或"regressor"的参数，并根据是否在no_decay中分为两组
    params_0 = [p for n,p in named_parameters if ("pooler" in n or "regressor" in n) 
                and any(nd in n for nd in no_decay)]
    params_1 = [p for n,p in named_parameters if ("pooler" in n or "regressor" in n)
                and not any(nd in n for nd in no_decay)]
    # 为这两组参数创建一个字典，指定学习率和权重衰减系数，并将其添加到优化器的参数列表中
    head_params = {"params": params_0, "lr": head_lr, "weight_decay": 0.0}    
    opt_parameters.append(head_params)
        
    head_params = {"params": params_1, "lr": head_lr, "weight_decay": 0.01}    
    opt_parameters.append(head_params)
    # 从第11层到第0层遍历编码器的每一层
    for layer in range(11,-1,-1): 
        # 从命名参数中筛选出属于当前层的参数，并根据是否在no_decay中分为两组       
        params_0 = [p for n,p in named_parameters if f"encoder.layer.{layer}." in n 
                    and any(nd in n for nd in no_decay)]
        params_1 = [p for n,p in named_parameters if f"encoder.layer.{layer}." in n 
                    and not any(nd in n for nd in no_decay)]
        # 为这两组参数创建一个字典，指定学习率和权重衰减系数，并将其添加到优化器的参数列表中
        layer_params = {"params": params_0, "lr": lr, "weight_decay": 0.0}
        opt_parameters.append(layer_params)   
                            
        layer_params = {"params": params_1, "lr": lr, "weight_decay": 0.01}
        opt_parameters.append(layer_params)       
        # 每遍历一层，就将学习率乘以一个衰减因子（这里是0.9）
        lr *= 0.9     
    # 从命名参数中筛选出包含"embeddings"的参数，并根据是否在no_decay中分为两组 
    params_0 = [p for n,p in named_parameters if "embeddings" in n 
                and any(nd in n for nd in no_decay)]
    params_1 = [p for n,p in named_parameters if "embeddings" in n
                and not any(nd in n for nd in no_decay)]
    # 为这两组参数创建一个字典，指定学习率和权重衰减系数，并将其添加到优化器的参数列表中
    embed_params = {"params": params_0, "lr": lr, "weight_decay": 0.0} 
    opt_parameters.append(embed_params)
        
    embed_params = {"params": params_1, "lr": lr, "weight_decay": 0.01} 
    opt_parameters.append(embed_params)        
    # 使用优化器的参数列表和初始学习率创建一个AdamW优化器对象
    return AdamW(opt_parameters, lr=init_lr)

def bert_base_adamw_grouped_llrd(model):
        
    opt_parameters = [] # 创建一个空列表，用于存储优化器的参数
    named_parameters = list(model.named_parameters()) # 获取模型中所有命名参数，并转换为列表
    no_decay = ["bias", "LayerNorm.bias", "LayerNorm.weight"]# 定义不需要进行权重衰减的参数名
    set_2 = ["layer.4", "layer.5", "layer.6", "layer.7"]
    set_3 = ["layer.8", "layer.9", "layer.10", "layer.11"]
    init_lr = 1e-8
    # 定义第二组和第三组参数名，这些参数的学习率会比初始学习率（1e-8）高1.75倍和35倍
    for i, (name, params) in enumerate(named_parameters):  
        
        weight_decay = 0.0 if any(p in name for p in no_decay) else 0.01# 根据参数名判断是否需要进行权重衰减，如果是，则设为0，否则设为0.01   
        lr = init_lr    
        lr = init_lr * 1.75 if any(p in name for p in set_2) else lr
        lr = init_lr * 35 if any(p in name for p in set_3) else lr
        opt_parameters.append({"params": params,
                                "weight_decay": weight_decay,
                                "lr": lr})# 将当前参数及其权重衰减和学习率添加到优化器参数列表中
    return AdamW(opt_parameters, lr=init_lr)# 返回一个使用AdamW优化器和分组LLRD策略的优化器对象

scheduler = get_linear_schedule_with_warmup(optimizer, 
                                            num_warmup_steps = 50,
                                            num_training_steps = total_steps)

from transformers import BertForSequenceClassification, AdamW, BertConfig
from transformers import logging
logging.set_verbosity_warning()
logging.set_verbosity_error()

reinit_layers = 3# 设置重新初始化的层数为3
_model_type = 'bert'
_pretrained_model = 'bert-base-uncased'
config = BertConfig.from_pretrained(_pretrained_model)# 从预训练模型创建配置对象
model = BertForSequenceClassification.from_pretrained(_pretrained_model, num_labels = 2,
    output_attentions = False,
    output_hidden_states = False)# 从预训练模型创建一个用于序列分类的Bert模型，并设置输出类别数为2，不输出注意力和隐藏状态

if reinit_layers > 0:
    print(f'Reinitializing Last {reinit_layers} Layers ...')
    encoder_temp = getattr(model, _model_type)# 获取Bert模型中的编码器部分，并赋值给encoder_temp变量
    for layer in encoder_temp.encoder.layer[-reinit_layers:]:# 遍历编码器中最后几层
        for module in layer.modules():
            if isinstance(module, nn.Linear):# 如果子模块是线性层，则对其权重和偏置进行正态分布初始化或置零操作
                module.weight.data.normal_(mean=0.0, std=config.initializer_range)
                if module.bias is not None:
                    module.bias.data.zero_()
            elif isinstance(module, nn.Embedding):# 如果子模块是嵌入层，则对其权重进行正态分布初始化或置零操作
                module.weight.data.normal_(mean=0.0, std=config.initializer_range)
                if module.padding_idx is not None:
                    module.weight.data[module.padding_idx].zero_()
            elif isinstance(module, nn.LayerNorm): # 如果子模块是层归一化，则对其偏置置零，对其权重设为1.0
                module.bias.data.zero_()
                module.weight.data.fill_(1.0)
    print('Done.!')
model.cuda()