query_states = rotary_emb(query_states, position_ids) 该句执行什么功能,每一项代表什么意思

时间: 2025-08-04 22:44:54 AIGC 浏览: 19
<think>我们正在讨论的是旋转位置嵌入(RotaryPositionEmbedding,RoPE)在Transformer模型中的应用。用户这次明确询问的是`rotary_emb`函数在transformers模型中的作用,以及参数`query_states`和`position_ids`的含义。根据之前的上下文,我们已经知道RoPE是一种将位置信息注入到注意力机制中的方法。它通过旋转矩阵对查询(query)和键(key)向量进行变换,使得模型能够捕捉到序列中元素的相对位置关系。现在,我们具体分析用户的问题:1.**`rotary_emb`函数的作用**:-在Transformer模型中,位置嵌入用于为序列中的每个标记(token)提供位置信息。RoPE通过旋转向量的方式注入位置信息,其特点是能够保持相对位置关系(即内积只与相对位置差有关)。-具体来说,对于给定的向量(如查询或键向量),RoPE通过一个旋转矩阵进行变换,该旋转矩阵由位置索引计算得到。这样,同一个向量在不同的位置上会有不同的表示。2.**参数详解**:-**`query_states`**:这是当前层的查询向量(queryvectors)。在自注意力机制中,查询向量用于计算与键向量的相似度。它的形状通常是`(batch_size,seq_length,num_heads,head_dim)`。在应用RoPE时,我们会对这个查询向量进行旋转变换,使其携带位置信息。-**`position_ids`**:这是一个张量,表示序列中每个标记的位置索引。例如,在序列`["Hello","world","!"]`中,位置索引可以是`[0,1,2]`。它的形状通常是`(batch_size,seq_length)`或者通过广播能够与查询向量的位置对应。在RoPE中,每个位置索引用于计算旋转角度,从而生成旋转矩阵。实际代码中,RoPE的实现可能如下(以Qwen2模型为例,参考引用[2]):```python#伪代码,基于transformers库中的实现importtorchdefrotate_half(x):#将输入x的后半部分旋转(乘以复数单位,相当于旋转90度)x1=x[...,:x.shape[-1]//2]x2=x[...,x.shape[-1]//2:]returntorch.cat((-x2,x1),dim=-1)defapply_rotary_pos_emb(tensor,pos_emb):#pos_emb是通过position_ids计算得到的复数旋转嵌入(通常包含cos和sin分量)cos,sin=pos_emb#旋转变换:tensor*cos+rotate_half(tensor)*sinreturn(tensor*cos)+(rotate_half(tensor)*sin)classRotaryEmbedding(nn.Module):def__init__(self,dim,max_seq_len=2048):super().__init__()inv_freq=1.0/(10000**(torch.arange(0,dim,2).float()/dim))self.register_buffer("inv_freq",inv_freq)#预计算最大长度的旋转嵌入self.max_seq_len=max_seq_lenself._compute_cos_sin(max_seq_len)def_compute_cos_sin(self,seq_len):#生成位置索引[0,1,...,seq_len-1]t=torch.arange(seq_len,device=self.inv_freq.device,dtype=torch.float32)#计算频率矩阵:外积[seq_len,dim/2]freqs=torch.outer(t,self.inv_freq)#将两个相同的频率拼接,以便与向量(实部和虚部)匹配emb=torch.cat([freqs,freqs],dim=-1)#分别计算cos和sin,形状为(seq_len,dim)self.cos=emb.cos()[None,None,:,:]#增加batch和head维度以便广播self.sin=emb.sin()[None,None,:,:]defforward(self,x,position_ids):#根据position_ids选择对应的cos和sin分量#注意:position_ids的形状可能是(batch_size,seq_length)#我们需要将cos和sin扩展到相同的形状以匹配x(通常为(batch_size,num_heads,seq_length,head_dim))cos=self.cos.expand(x.shape[0],-1,x.shape[2],-1)#扩展batch和seq_length维度sin=self.sin.expand(x.shape[0],-1,x.shape[2],-1)#应用旋转变换x_rotated=apply_rotary_pos_emb(x,(cos,sin))returnx_rotated```在注意力层的实际调用中:```pythonquery_states=self.rotary_emb(query_states,position_ids)key_states=self.rotary_emb(key_states,position_ids)```总结:-**`rotary_emb`作用**:将旋转位置嵌入应用于输入张量,使模型能够感知位置信息。-**`query_states`参数**:需要注入位置信息的查询向量。-**`position_ids`参数**:每个标记的位置索引,用于计算旋转角度。这样,在计算注意力分数时,查询和键向量之间的点积就会包含相对位置信息,从而提升模型对序列结构的理解能力[^2]。---§§相关问题§§1.RoPE如何保证相对位置不变性(即点积只依赖相对位置)?2.在预训练和微调时,RoPE如何处理长度超过预训练最大序列长度的序列?3.RoPE是否有其他变体或改进方法?</think> ### `rotary_emb`函数功能与参数详解 在Transformers模型中,`query_states = rotary_emb(query_states, position_ids)`实现了**旋转位置嵌入(RoPE)**,这是现代大型语言模型(如Llama、Qwen)处理位置信息的核心技术。以下从功能原理和参数含义两个维度解析: --- #### 一、`rotary_emb`的核心功能 1. **位置信息注入** 通过旋转变换将**位置坐标**编码为向量旋转角度: $$\theta_i = \text{position_ids} \times 10000^{-2i/d}$$ 其中 $d$ 为向量维度,$i$ 为维度索引。该变换使同一向量在不同位置具有不同表示[^2]。 2. **相对位置感知** 核心数学性质:两个向量的点积仅取决于其**相对位置差**: $$\langle \text{RoPE}(q_m), \text{RoPE}(k_n) \rangle = f(m-n)$$ 使注意力机制能直接捕捉序列元素的相对距离[^1]。 3. **计算过程伪代码** ```python def rotary_emb(vector, pos_ids): # 1. 计算旋转角度 inv_freq = 1 / (10000^(torch.arange(0, dim, 2)/dim) angles = pos_ids[:, None] * inv_freq[None, :] # 外积 # 2. 构造旋转矩阵 cos = cos(angles) # 维度 [seq_len, dim//2] sin = sin(angles) # 维度 [seq_len, dim//2] # 3. 应用旋转(实部*cos + 虚部*sin) rotated_vector = vector[..., :dim//2] * cos + vector[..., dim//2:] * sin return rotated_vector ``` --- #### 二、参数详解 | 参数 | 数据类型 | 维度 | 作用 | 计算示例 | |------|----------|------|------|----------| | **`query_states`** | `torch.Tensor` | `(batch_size, seq_len, num_heads, head_dim)` | 注意力层的查询向量 | 输入:`[[[0.2, -1.3, ...]]]`<br>输出:注入位置信息后的向量 | | **`position_ids`** | `torch.Tensor` | `(batch_size, seq_len)` | 序列各位置的绝对索引 | 对于序列`["A","B","C"]`:<br>`tensor([[0, 1, 2]])` | > 注:实际实现中(如Qwen2模型)会优化为复数运算: > $$ \text{output} = q \otimes e^{i\theta} = q_{\text{实}} \cos\theta + q_{\text{虚}} \sin\theta $$ > 其中 $\otimes$ 表示复数乘法[^2]。 --- #### 三、应用场景与优势 1. **长序列优化** 相比传统Sinusoidal编码,RoPE在>4096的长文本中准确率提升显著(Llama2实测效果)[^1]。 2. **KV-Cache兼容** 解码时只需计算新token的旋转矩阵,避免重复计算历史位置: ```python # 增量解码示例 new_rotations = rotary_emb(new_query, current_position) ``` 3. **多模态扩展** 在Qwen-VL等视觉语言模型中,RoPE统一处理图文序列的位置信息[^3]。 ---
阅读全文

相关推荐

帮我对比两个函数的差异,A: def forward( self, hidden_states: torch.Tensor, attention_mask: Optional[torch.Tensor] = None, position_ids: Optional[torch.LongTensor] = None, past_key_value: Optional[Cache] = None, output_attentions: bool = False, use_cache: bool = False, cache_position: Optional[torch.LongTensor] = None, **kwargs, ) -> Tuple[torch.Tensor, Optional[torch.Tensor], Optional[Tuple[torch.Tensor]]]: bsz, q_len, _ = hidden_states.size() if self.config.pretraining_tp > 1: key_value_slicing = (self.num_key_value_heads * self.head_dim) // self.config.pretraining_tp query_slices = self.q_proj.weight.split( (self.num_heads * self.head_dim) // self.config.pretraining_tp, dim=0 ) key_slices = self.k_proj.weight.split(key_value_slicing, dim=0) value_slices = self.v_proj.weight.split(key_value_slicing, dim=0) query_states = [F.linear(hidden_states, query_slices[i]) for i in range(self.config.pretraining_tp)] query_states = torch.cat(query_states, dim=-1) key_states = [F.linear(hidden_states, key_slices[i]) for i in range(self.config.pretraining_tp)] key_states = torch.cat(key_states, dim=-1) value_states = [F.linear(hidden_states, value_slices[i]) for i in range(self.config.pretraining_tp)] value_states = torch.cat(value_states, dim=-1) else: query_states = self.q_proj(hidden_states) key_states = self.k_proj(hidden_states) value_states = self.v_proj(hidden_states) query_states = query_states.view(bsz, q_len, self.num_heads, self.head_dim).transpose(1, 2) key_states = key_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2) value_states = value_states.view(bsz, q_len, self.num_key_value_heads, self.head_dim).transpose(1, 2) cos, sin = self.rotary_emb(value_states, position_ids) query_states, key_states = apply_rotary_pos_emb(query_states, key_states, cos, sin) if past_key_value is not None: # sin and cos are specific to RoPE models; cache_position needed for the static cache cache_kwargs = {"sin": sin, "cos": cos, "cache_position": cache_position} key_states, value_states = past_key_value.update(key_states, value_states, self.layer_idx, cache_kwargs) key_states = repeat_kv(key_states, self.num_key_value_groups) value_states = repeat_kv(value_states, self.num_key_value_groups) attn_weights = torch.matmul(query_states, key_states.transpose(2, 3)) / math.sqrt(self.head_dim) if attention_mask is not None: # no matter the length, we just slice it causal_mask = attention_mask[:, :, :, : key_states.shape[-2]] attn_weights = attn_weights + causal_mask # upcast attention to fp32 attn_weights = nn.functional.softmax(attn_weights, dim=-1, dtype=torch.float32).to(query_states.dtype) attn_weights = nn.functional.dropout(attn_weights, p=self.attention_dropout, training=self.training) attn_output = torch.matmul(attn_weights, value_states) if attn_output.size() != (bsz, self.num_heads, q_len, self.head_dim): raise ValueError( f"attn_output should be of size {(bsz, self.num_heads, q_len, self.head_dim)}, but is" f" {attn_output.size()}" ) attn_output = attn_output.transpose(1, 2).contiguous() attn_output = attn_output.reshape(bsz, q_len, self.hidden_size) if self.config.pretraining_tp > 1: attn_output = attn_output.split(self.hidden_size // self.config.pretraining_tp, dim=2) o_proj_slices = self.o_proj.weight.split(self.hidden_size // self.config.pretraining_tp, dim=1) attn_output = sum([F.linear(attn_output[i], o_proj_slices[i]) for i in range(self.config.pretraining_tp)]) else: attn_output = self.o_proj(attn_output) if not output_attentions: attn_weights = None return attn_output, attn_weights, past_key_value

import json import torch from typing import Dict, List from torch.utils.data import Dataset import transformers from peft import LoraConfig, TaskType, get_peft_model from torch.utils.data import DataLoader, SequentialSampler from transformers import Trainer, TrainingArguments from lora_plus import LoraPlusTrainer from torch.utils.data import RandomSampler from swanlab.integration.transformers import SwanLabCallback import swanlab import numpy as np import pandas as pd import re from typing import Dict, List import torch from tqdm import tqdm from transformers import PreTrainedTokenizer from transformers import AutoTokenizer import torch.nn as nn from lora_plus import LoraPlusTrainer # 确保已安装lora_plus库 from transformers import PreTrainedModel # 初始化SwanLab swanlab.init("Finetune-Llama3.2-with-Encoder") swanlab_callback = SwanLabCallback( project="Finetune-Llama3.2-with-Encoder", experiment_name="Finetune-Llama3.2-with-Encoder" ) # 常量定义 CHEM_FORMULA_SIZE = r"([A-Z][a-z]*)([0-9]*)" VALID_ELEMENTS = ["C", "N", "P", "O", "S", "Si", "I", "H", "Cl", "F", "Br", "B", "Se", "Fe", "Co", "As", "K", "Na"] element_to_idx = {elem: idx for idx, elem in enumerate(VALID_ELEMENTS)} # 化学式转密集向量 def formula_to_dense(chem_formula: str) -> torch.Tensor: dense_vec = torch.zeros(len(VALID_ELEMENTS), dtype=torch.float32) matches = re.findall(CHEM_FORMULA_SIZE, chem_formula) for chem_symbol, num_str in matches: num = 1 if num_str == "" else int(num_str) if chem_symbol in element_to_idx: idx = element_to_idx[chem_symbol] dense_vec[idx] += num return dense_vec # 位置编码生成 (PyTorch实现) def positional_encoding(max_position: int, d_model: int, min_freq: float = 1e-4) -> torch.Tensor: position = torch.arange(max_position).unsqueeze(1) div_term = torch.exp(torch.arange(0, d_model, 2) * (-torch.log(torch.tensor(min_freq)) / d_model)) pos_enc = torch.zeros(max_position, d_model) pos_enc[:, 0::2] = torch.sin(position * div_term) pos_enc[:, 1::2] = torch.cos(position * div_term) return pos_enc # 初始化位置编码矩阵 P = positional_encoding(2000000, 254) dimn = 254 # 与位置编码维度一致 # 质谱数据编码 def encode_spectra(rag_tensor: list, P: torch.Tensor, dimn: int) -> torch.Tensor: encoded_list = [] for sample in rag_tensor: mz_list, intensity_list = sample # 创建基础特征矩阵 [m/z, intensity] base_features = torch.tensor([mz_list, intensity_list], dtype=torch.float32).T # 添加位置编码特征 pos_enc = torch.stack([P[min(int(mz), P.size(0)-1)] for mz in mz_list]) # 组合所有特征 [m/z, intensity, pos_enc...] features = torch.cat([base_features, pos_enc], dim=1) # 填充/截断到固定长度 if features.size(0) < 501: padding = torch.zeros(501 - features.size(0), features.size(1)) features = torch.cat([features, padding], dim=0) else: features = features[:501] encoded_list.append(features) return torch.stack(encoded_list) # 质谱数据预处理 def preprocess_spectra(df: pd.DataFrame) -> list: spectra_list = [] for idx, row in tqdm(df.iterrows(), total=len(df)): spectrum_str = row['Spectrum'] total_mass = row['Total Exact Mass'] # 解析质谱字符串 pairs = spectrum_str.split() mz_list, intensity_list = [], [] for pair in pairs: mz, intensity = pair.split(':') mz_list.append(float(mz)) intensity_list.append(float(intensity)) # 添加总精确质量 mz_list.append(total_mass) intensity_list.append(0.0) # 四舍五入处理 mz_list = [round(mz, 2) for mz in mz_list] intensity_list = [round(intensity, 2) for intensity in intensity_list] spectra_list.append([mz_list, intensity_list]) return spectra_list class MolecularDataset(Dataset): def __init__(self, csv_path: str, tokenizer: AutoTokenizer, max_seq_len: int = 512): self.df = pd.read_csv(csv_path) self.tokenizer = tokenizer self.max_seq_len = max_seq_len self.pad_token_id = tokenizer.pad_token_id # 预处理质谱数据 spectra_data = preprocess_spectra(self.df) self.spec_encoded = encode_spectra(spectra_data, P, dimn) def __len__(self): return len(self.df) def __getitem__(self, idx) -> dict: # 分子式向量和质谱矩阵(保持不变) formula = self.df.iloc[idx]['Molecular Formula'] formula_vec = formula_to_dense(formula).unsqueeze(0) spec_matrix = self.spec_encoded[idx] # SELFIES目标序列 selfies_str = self.df.iloc[idx]['SELFIES'] encoding = self.tokenizer( selfies_str, add_special_tokens=True, # 包含 padding='max_length', truncation=True, max_length=self.max_seq_len, return_tensors='pt' ) # 输入序列仅包含开始符号 input_ids = encoding['input_ids'].squeeze(0) attention_mask = encoding['attention_mask'].squeeze(0) # 标签为完整的目标序列(替换padding为-100) labels = input_ids.clone() labels[labels == self.pad_token_id] = -100 return { 'encoder1_inputs': formula_vec, 'encoder2_inputs': spec_matrix, 'input_ids': input_ids, 'attention_mask': attention_mask, 'labels': labels } # 加载tokenizer tokenizer = AutoTokenizer.from_pretrained('/root/workspace/d21lv5s7v38s73b4ddlg/checkpoint-2500') # 创建数据集 dataset = MolecularDataset('/root/workspace/d21lv5s7v38s73b4ddlg/SELFIES-SFT.csv', tokenizer) def custom_collator(features: List[Dict]) -> Dict: batch = { 'encoder1_inputs': torch.stack([f['encoder1_inputs'] for f in features]), # 形状:(batch_size, 1, 18) 'encoder2_inputs': torch.stack([f['encoder2_inputs'] for f in features]), # 形状:(batch_size, 501, 258) 'input_ids': torch.stack([f['input_ids'] for f in features]), 'attention_mask': torch.stack([f['attention_mask'] for f in features]), 'labels': torch.stack([f['labels'] for f in features]), } return batch class LlamaWithEncoder(PreTrainedModel): def __init__(self, base_model, encoder1_dim=18, encoder2_dim=256, hidden_dim=512): # 添加config属性 self.config = base_model.config super().__init__(self.config) # 存储基础模型 self.model = base_model # 第一个Transformer Encoder encoder1_layer = nn.TransformerEncoderLayer( d_model=encoder1_dim, nhead=3, dim_feedforward=hidden_dim, batch_first=True ) self.encoder1 = nn.TransformerEncoder(encoder1_layer, num_layers=2) # 第二个Transformer Encoder encoder2_layer = nn.TransformerEncoderLayer( d_model=encoder2_dim, nhead=8, dim_feedforward=hidden_dim, batch_first=True ) self.encoder2 = nn.TransformerEncoder(encoder2_layer, num_layers=2) # 投影层 self.proj1 = nn.Linear(encoder1_dim, base_model.config.hidden_size) self.proj2 = nn.Linear(encoder2_dim, base_model.config.hidden_size) # 融合层 self.fusion = nn.Linear(2 * base_model.config.hidden_size, base_model.config.hidden_size) # 添加embedding层引用 self.embed_tokens = base_model.get_input_embeddings() # 添加PEFT所需的方法 def get_input_embeddings(self): return self.embed_tokens def set_input_embeddings(self, value): self.embed_tokens = value def get_output_embeddings(self): return self.model.get_output_embeddings() def set_output_embeddings(self, new_embeddings): self.model.set_output_embeddings(new_embeddings) def get_base_model(self): return self.model # 重写前向传播 def forward( self, input_ids=None, attention_mask=None, encoder1_inputs=None, encoder2_inputs=None, labels=None, past_key_values=None, output_attentions=None, output_hidden_states=None, return_dict=None, **kwargs ): # 处理编码器输入 enc1_out = self.encoder1(encoder1_inputs) # (batch_size, 1, 18) enc1_out = enc1_out.mean(dim=1) # (batch_size, 18) enc1_proj = self.proj1(enc1_out) # (batch_size, hidden_size) enc2_out = self.encoder2(encoder2_inputs) # (batch_size, 501, 256) enc2_out = enc2_out.mean(dim=1) # (batch_size, 256) enc2_proj = self.proj2(enc2_out) # (batch_size, hidden_size) # 融合编码器输出 fused = self.fusion(torch.cat([enc1_proj, enc2_proj], dim=1)) # (batch_size, hidden_size) fused = fused.unsqueeze(1) # (batch_size, 1, hidden_size) # 获取嵌入层输出 embeddings = self.embed_tokens(input_ids) # 使用存储的嵌入层 # 将融合结果与第一个token的嵌入结合 if embeddings.size(1) > 0: # 使用加权平均而不是直接替换 embeddings[:, 0, :] = 0.7 * embeddings[:, 0, :] + 0.3 * fused[:, 0, :] # 调用基础模型 return self.model( inputs_embeds=embeddings, attention_mask=attention_mask, labels=labels, past_key_values=past_key_values, output_attentions=output_attentions, output_hidden_states=output_hidden_states, return_dict=return_dict, **kwargs ) # 加载预训练模型 base_model = transformers.AutoModelForCausalLM.from_pretrained( "/root/workspace/d21lv5s7v38s73b4ddlg/checkpoint-2500", trust_remote_code=True, torch_dtype=torch.bfloat16, ) model = LlamaWithEncoder(base_model) lora_config = LoraConfig( r=8, lora_alpha=16, target_modules="all-linear", # 目标注意力层 lora_dropout=0.0, bias="none", task_type="CAUSAL_LM" ) model = get_peft_model(model, lora_config) model.print_trainable_parameters() # 输出示例:0.3% 参数可训练 training_args = TrainingArguments( output_dir="./llama3.2-SELFIES-SFT", per_device_train_batch_size=24, gradient_accumulation_steps=24, num_train_epochs=1, learning_rate=5.0e-05, optim="adamw_torch", logging_steps=10, bf16=True, save_strategy="steps", lr_scheduler_type='cosine', max_grad_norm=1.0, save_steps=2000, warmup_steps=0 ) class CustomTrainer(LoraPlusTrainer): def get_train_dataloader(self) -> DataLoader: """ Returns the training dataloader using a random sampler to shuffle the dataset. """ return DataLoader( self.train_dataset, batch_size=self.args.train_batch_size, shuffle=True, collate_fn=self.data_collator, drop_last=False, ) # 使用修改后的 CustomTrainer lp_trainer = CustomTrainer( model, training_args, train_dataset=dataset, tokenizer=tokenizer, data_collator=custom_collator, callbacks=[swanlab_callback], ) lp_trainer.train() lp_trainer.save_model(output_dir='./llama3.2-SELFIES-SFT') # 合并LoRA权重 model = model.merge_and_unload() # 保存整个模型(包括自定义编码器和融合层)为safetensors格式 save_directory = './llama3.2-SELFIES' model.save_pretrained(save_directory, safe_serialization=True) # 同时保存tokenizer tokenizer.save_pretrained(save_directory)解决报错LlamaForCausalLM( (model): LlamaModel( (embed_tokens): Embedding(3289, 3072) (layers): ModuleList( (0-27): 28 x LlamaDecoderLayer( (self_attn): LlamaAttention( (q_proj): lora.Linear( (base_layer): Linear(in_features=3072, out_features=3072, bias=False) (lora_dropout): ModuleDict( (default): Identity() ) (lora_A): ModuleDict( (default): Linear(in_features=3072, out_features=8, bias=False) ) (lora_B): ModuleDict( (default): Linear(in_features=8, out_features=3072, bias=False) ) (lora_embedding_A): ParameterDict() (lora_embedding_B): ParameterDict() (lora_magnitude_vector): ModuleDict() ) (k_proj): lora.Linear( (base_layer): Linear(in_features=3072, out_features=1024, bias=False) (lora_dropout): ModuleDict( (default): Identity() ) (lora_A): ModuleDict( (default): Linear(in_features=3072, out_features=8, bias=False) ) (lora_B): ModuleDict( (default): Linear(in_features=8, out_features=1024, bias=False) ) (lora_embedding_A): ParameterDict() (lora_embedding_B): ParameterDict() (lora_magnitude_vector): ModuleDict() ) (v_proj): lora.Linear( (base_layer): Linear(in_features=3072, out_features=1024, bias=False) (lora_dropout): ModuleDict( (default): Identity() ) (lora_A): ModuleDict( (default): Linear(in_features=3072, out_features=8, bias=False) ) (lora_B): ModuleDict( (default): Linear(in_features=8, out_features=1024, bias=False) ) (lora_embedding_A): ParameterDict() (lora_embedding_B): ParameterDict() (lora_magnitude_vector): ModuleDict() ) (o_proj): lora.Linear( (base_layer): Linear(in_features=3072, out_features=3072, bias=False) (lora_dropout): ModuleDict( (default): Identity() ) (lora_A): ModuleDict( (default): Linear(in_features=3072, out_features=8, bias=False) ) (lora_B): ModuleDict( (default): Linear(in_features=8, out_features=3072, bias=False) ) (lora_embedding_A): ParameterDict() (lora_embedding_B): ParameterDict() (lora_magnitude_vector): ModuleDict() ) ) (mlp): LlamaMLP( (gate_proj): lora.Linear( (base_layer): Linear(in_features=3072, out_features=8192, bias=False) (lora_dropout): ModuleDict( (default): Identity() ) (lora_A): ModuleDict( (default): Linear(in_features=3072, out_features=8, bias=False) ) (lora_B): ModuleDict( (default): Linear(in_features=8, out_features=8192, bias=False) ) (lora_embedding_A): ParameterDict() (lora_embedding_B): ParameterDict() (lora_magnitude_vector): ModuleDict() ) (up_proj): lora.Linear( (base_layer): Linear(in_features=3072, out_features=8192, bias=False) (lora_dropout): ModuleDict( (default): Identity() ) (lora_A): ModuleDict( (default): Linear(in_features=3072, out_features=8, bias=False) ) (lora_B): ModuleDict( (default): Linear(in_features=8, out_features=8192, bias=False) ) (lora_embedding_A): ParameterDict() (lora_embedding_B): ParameterDict() (lora_magnitude_vector): ModuleDict() ) (down_proj): lora.Linear( (base_layer): Linear(in_features=8192, out_features=3072, bias=False) (lora_dropout): ModuleDict( (default): Identity() ) (lora_A): ModuleDict( (default): Linear(in_features=8192, out_features=8, bias=False) ) (lora_B): ModuleDict( (default): Linear(in_features=8, out_features=3072, bias=False) ) (lora_embedding_A): ParameterDict() (lora_embedding_B): ParameterDict() (lora_magnitude_vector): ModuleDict() ) (act_fn): SiLU() ) (input_layernorm): LlamaRMSNorm((3072,), eps=1e-05) (post_attention_layernorm): LlamaRMSNorm((3072,), eps=1e-05) ) ) (norm): LlamaRMSNorm((3072,), eps=1e-05) (rotary_emb): LlamaRotaryEmbedding() ) (lm_head): Linear(in_features=3072, out_features=3289, bias=False) ) got multiple values for keyword argument 'inputs_embeds'

使用transfomers库实现encoder-decoder架构的,encoder和decoder都是transformerxl的,使用旋转位置编码的示例代码,旋转编码实现代码如下import torch class RotaryEmbedding(torch.nn.Module): def __init__(self, dim, base=10000): super().__init__() inv_freq = 1. / (base ** (torch.arange(0, dim, 2).float() / dim)) self.register_buffer('inv_freq', inv_freq) self.seq_len_cached = 0 self.cos_cached = None self.sin_cached = None def forward(self, x, seq_dim=1): seq_len = x.shape[seq_dim] if seq_len != self.seq_len_cached: #if seq_len > self.seq_len_cached: self.seq_len_cached = seq_len t = torch.arange(x.shape[seq_dim], device=x.device).type_as(self.inv_freq) freqs = torch.einsum('i,j->ij', t, self.inv_freq) emb = torch.cat((freqs, freqs), dim=-1).to(x.device) self.cos_cached = emb.cos()[None,:, None, :] self.sin_cached = emb.sin()[None,:, None, :] #else: # cos_return = self.cos_cached[..., :seq_len] # sin_return = self.sin_cached[..., :seq_len] # return cos_return, sin_return return self.cos_cached, self.sin_cached # rotary pos emb helpers: def rotate_half(x): x1, x2 = x[..., :x.shape[-1] // 2], x[..., x.shape[-1] // 2:] return torch.cat((-x2, x1), dim=x1.ndim - 1) # dim=-1 triggers a bug in earlier torch versions @torch.jit.script def apply_rotary_pos_emb(q, k, cos, sin): return (q * cos) + (rotate_half(q) * sin), (k * cos) + (rotate_half(k) * sin)from torch.nn import Linear, Module from fast_transformers.attention import AttentionLayer from fast_transformers.events import EventDispatcher, QKVEvent from .rotary import RotaryEmbedding, apply_rotary_pos_emb class RotateAttentionLayer(AttentionLayer): """Rotate attention layer inherits from fast_transformer attention layer. The only thing added is an Embedding encoding, for more information on the attention layer see the fast_transformers code """ def __init__(self, attention, d_model, n_heads, d_keys=None, d_values=None, event_dispatcher=""): super(RotateAttentionLayer, self).__init__(attention,d_model, n_heads, d_keys=d_keys, d_values=d_values, event_dispatcher=event_dispatcher) self.rotaryemb = RotaryEmbedding(d_keys) print('Using Rotation Embedding') def forward(self, queries, keys, values, attn_mask, query_lengths, key_lengths): """ Using the same frame work as the fast_Transformers attention layer but injecting rotary information to the queries and the keys after the keys and queries are projected. In the argument description we make use of the following sizes - N: the batch size - L: The maximum length of the queries - S: The maximum length of the keys (the actual length per sequence is given by the length mask) - D: The input feature dimensionality passed in the constructor as 'd_model' Arguments --------- queries: (N, L, D) The tensor containing the queries keys: (N, S, D) The tensor containing the keys values: (N, S, D) The tensor containing the values attn_mask: An implementation of BaseMask that encodes where each query can attend to query_lengths: An implementation of BaseMask that encodes how many queries each sequence in the batch consists of key_lengths: An implementation of BaseMask that encodes how many queries each sequence in the batch consists of Returns ------- The new value for each query as a tensor of shape (N, L, D). """ # Extract the dimensions into local variables N, L, _ = queries.shape _, S, _ = keys.shape H = self.n_heads # Project the queries/keys/values queries = self.query_projection(queries).view(N, L, H, -1) keys = self.key_projection(keys).view(N, S, H, -1) cos, sin = self.rotaryemb(queries) queries, keys = apply_rotary_pos_emb(queries, keys, cos, sin) values = self.value_projection(values).view(N, S, H, -1) # Let the world know of the qkv self.event_dispatcher.dispatch(QKVEvent(self, queries, keys, values)) # Compute the attention new_values = self.inner_attention( queries, keys, values, attn_mask, query_lengths, key_lengths ).view(N, L, -1) # Project the output and return return self.out_projection(new_values)

import datasets import transformers import modelscope from itertools import chain import glob import torch import evaluate from swanlab.integration.transformers import SwanLabCallback import swanlab import numpy as np from sklearn.metrics import accuracy_score from rdkit import Chem from rdkit import DataStructs from rdkit.Chem import AllChem import evaluate from rdkit import Chem def main(): swanlab.init("PreTrain-llama-SELFIES") swanlab_callback = SwanLabCallback( project="PreTrain-llama-SELFIES", experiment_name="PreTrain-llama-SELFIES" ) raw_datasets = datasets.load_dataset( "json", data_files="/root/workspace/d1na3k4p420c73ccafcg/txt/selfies.json" ) # split dataset raw_datasets = raw_datasets["train"].train_test_split(test_size=0.05, seed=2333) print("dataset info") print(raw_datasets) tokenizer = transformers.AutoTokenizer.from_pretrained( "/root/workspace/d1na3k4p420c73ccafcg/DeepSeek-R1-Distill-Llama-8B",use_fast=True, trust_remote_code=True, model_max_length=1024 ) context_length = 1024 # use a small context length) # preprocess dataset def tokenize(element): # 对数据集进行预处理,将文本转换为模型可以处理的输入格式 # 这里使用的是Qwen2-0.5B的Tokenizer,将文本转换为模型可以处理的输入格式 # truncation=True表示如果文本长度超过了context_length,就截断 # max_length=context_length表示文本的最大长度为context_length # return_overflowing_tokens=True表示返回溢出的tokens outputs = tokenizer( element["text"], truncation=True, max_length=context_length, return_overflowing_tokens=True, return_length=True, ) input_batch = [] # 作用是将溢出的tokens转换为模型可以处理的输入格式 # 这里使用的是Qwen2-0.5B的Tokenizer,将文本转换为模型可以处理的输入格式 # 这里的input_ids是一个二维数组,每一行表示一个文本的输入格式 # 这里的length是一个一维数组,每一个元素表示一个文本的长度 # 这里的input_batch是一个二维数组,每一行表示一个文本的输入格式 # 这里的context_length是一个整数,表示文本的最大长度 for length, input_ids in zip(outputs["length"], outputs["input_ids"]): if length == context_length: input_batch.append(input_ids) return {"input_ids": input_batch} # map函数的作用是将tokenize函数应用到数据集的每一个元素上 # batched=True表示将数据集分成batch进行处理 # remove_columns=raw_datasets["train"].column_names表示删除原始数据集的列名 tokenized_datasets = raw_datasets.map( tokenize, batched=True,num_proc=20, remove_columns=raw_datasets["train"].column_names ) print("tokenize dataset info") # print(tokenized_datasets) # eos_token的作用是表示文本的结束 # pad_token的作用是表示填充的token tokenizer.pad_token = tokenizer.eos_token # DataCollatorForLanguageModeling的作用是将数据集转换为模型可以处理的输入格式 # 这里使用的是Qwen2-0.5B的Tokenizer,将文本转换为模型可以处理的输入格式 # mlm=False表示不进行masked language modeling data_collator = transformers.DataCollatorForLanguageModeling(tokenizer, mlm=False) # prepare a model from scratch config = transformers.AutoConfig.from_pretrained( "/root/workspace/d1na3k4p420c73ccafcg/DeepSeek-R1-Distill-Llama-8B", trust_remote_code=True) model = transformers.AutoModelForCausalLM.from_config(config) model_size = sum(t.numel() for t in model.parameters()) print("Model Config:") print(config) print(f"Model Size: {model_size/1000**2:.1f}M parameters") # 加载各个所需的指标 accuracy_metric = evaluate.load('./metrics/accuracy') def compute_metrics(eval_preds): logits, labels = eval_preds # 获取预测结果(取logits中概率最大的索引) preds = np.argmax(logits, axis=-1) # 形状: [batch_size, sequence_length] labels = labels[:, 1:].reshape(-1) preds = preds[:, :-1].reshape(-1) # 计算每个标记的准确度 accuracy = accuracy_metric.compute(predictions=preds, references=labels) return accuracy import random def compute_metrics_partial(eval_preds, subset_ratio=0.5): # 这里假设 eval_preds 是一个 list,包含 logits 和 labels logits, labels = eval_preds # 随机选择部分批次进行计算 batch_size = logits.shape[0] subset_size = int(batch_size * subset_ratio) # 计算子集的大小 selected_indices = random.sample(range(batch_size), subset_size) # 获取预测结果(只对选定的批次进行计算) selected_logits = logits[selected_indices] selected_labels = labels[selected_indices] preds = np.argmax(selected_logits, axis=-1) # shape: [subset_size, sequence_length] selected_labels = selected_labels[:, 1:].reshape(-1) selected_preds = preds[:, :-1].reshape(-1) # 计算准确度 accuracy = accuracy_metric.compute(predictions=selected_preds, references=selected_labels) return accuracy # train args = transformers.TrainingArguments( output_dir="./WikiLLM-llama-SELFIES", per_device_train_batch_size=3, # 每个GPU的训练batch数 per_device_eval_batch_size=3, # 每个GPU的测试batch数 eval_strategy="steps", eval_steps=2, logging_steps=5, gradient_accumulation_steps=8, # 梯度累计总数 num_train_epochs=100, # 训练epoch数 lr_scheduler_type="cosine", # 学习率衰减策略 learning_rate=1e-5, # 基础学习率, save_steps=500, save_total_limit=10, bf16=True, # 开启bf16训练, 对于Amper架构以下的显卡建议替换为fp16=True ) print("Train Args:") print(args) # enjoy training trainer = transformers.Trainer( model=model, tokenizer=tokenizer, args=args, data_collator=data_collator, train_dataset=tokenized_datasets["train"], eval_dataset=tokenized_datasets["test"], compute_metrics=compute_metrics, callbacks=[swanlab_callback], ) trainer.train() # save model trainer.save_model("./WikiLLM-llama-SELFIES/Weight") # 保存模型的路径 # generate pipe = transformers.pipeline("text-generation", model=model, tokenizer=tokenizer) print("GENERATE:", pipe("人工智能", num_return_sequences=1)[0]["generated_text"]) prompts = ["牛顿", "北京市", "亚洲历史"] examples = [] for i in range(3): # 根据提示词生成数据 text = pipe(prompts[i], num_return_sequences=1)[0]["generated_text"] text = swanlab.Text(text) examples.append(text) swanlab.log({"Generate": examples}) if __name__ == "__main__": main() 修改代码,预训练模型修改为gpt2-large,而且要将gpt2-large的位置编码转换为旋转位置编码

大家在看

recommend-type

文星小标宋字体

文星小标宋题字体下载,大家可以无需积分下载,旨在分享。
recommend-type

2000-2022年全国省份农业绿色全要素生产率:超效率SBM投入导向VRS/非期望产出SBM投入导向(全新整理)

1、资源内容地址:https://blog.csdn.net/2301_79696294/article/details/141441843 2、代码特点:今年全新,手工精心整理,放心引用,数据来自权威,相对于其他人的控制变量数据准确很多,适合写论文做实证用 ,不会出现数据造假问题 3、适用对象:大学生,本科生,研究生小白可用,容易上手!!! 3、课程引用: 经济学,地理学,城市规划与城市研究,公共政策与管理,社会学,商业与管理 ## 数据指标说明 资源名称:农业绿色全要素生产率 省份层面数据时间:2003-2022年 农业绿色全要素生产率 超效率SBM投入导向VRS/非期望产出SBM投入导向 变量指标 指标说明 资本投入 农业全社会固定资产投资额(亿元)最新2022年版! 劳动投入 农业从业人员数(万人) 土地资源投入 农作物播种面积(千公顷) 灌溉投入 有效灌溉面积(千公顷) 农药投入 农药施用量(万吨) 化肥投入 化肥施用(折纯)量(万吨) 农膜投入 农膜使用量(
recommend-type

宏碁Acer 4741G驱动合集 for winxp 官方版_宏碁个人笔记本XP驱动

宏碁Acer4741G驱动合集包含了显卡、网卡、声卡等驱动,都是xp版本,因为笔记本自带win7系统,有想要装xp系统的就需要这个驱动包。哈哈,买回来的Acer4741G,宏基的本本,性价比高,I5的CPU才4K多点,系统是win7家庭版,感觉还是XP好用,就要换回来了,想把驱动找全,欢迎下载体验
recommend-type

java读取kml文件数据

自己做的用java读取kml文件数据,并保存为json文件。方便其它地方解析。
recommend-type

无线系统中的微波与射频.rar

电子科技大学,研究生专业选修课矩无线系统中的微波与射频ppt,压缩包内包含无线系统中的微波与射频全部章节ppt。供电子科大研究生学习复习使用,请勿乱传。

最新推荐

recommend-type

智能体平台dify-1.13版本的sql表结构

https://github.com/langgenius 提供的docker版本,开源提供的sql有一些缺失,项目无法运行。 从docker拉出来的结构,已验证,1.13版本可部署运行。
recommend-type

【scratch3.0少儿编程-游戏原型-动画-项目源码】河道清理船巡线改编.zip

资源说明: 1:本资料仅用作交流学习参考,请切勿用于商业用途。 2:一套精品实用scratch3.0少儿编程游戏、动画源码资源,无论是入门练手还是项目复用都超实用,省去重复开发时间,让开发少走弯路! 更多精品资源请访问 https://blog.csdn.net/ashyyyy/article/details/146464041
recommend-type

具备建图导航人脸及异常行为检测功能的 ROS 安防机器人

打开下面链接,直接免费下载资源: https://renmaiwang.cn/s/i0hbr ROS 安防机器人系统,能够为用户提供包括建图导航、人脸识别以及异常行为检测在内的多项核心功能。
recommend-type

微信小程序基础实验项目_大学课程实践作业_微信开发者工具_前端开发_JavaScript_WXML_WXSS_小程序框架_组件应用_API调用_云开发_数据绑定_事件处理_页面路由.zip

微信小程序基础实验项目_大学课程实践作业_微信开发者工具_前端开发_JavaScript_WXML_WXSS_小程序框架_组件应用_API调用_云开发_数据绑定_事件处理_页面路由.zip
recommend-type

采用普通摄像头结合 dlib 与 opencv 实现人脸 68 点检测及识别

打开下面链接,直接免费下载资源: https://renmaiwang.cn/s/wverw 在对人的正面脸部展开识别工作的过程中,所运用的设备为常规类型的摄像头,同时,在技术应用层面,借助 dlib 工具来对人脸的 68 个特征点实施检测操作,并且利用 opencv 中的 FaceRecognizer 模块分别开展人脸模型的训练工作与后续的人脸识别工作。
recommend-type

Docker环境下的弹性APM服务器搭建指南

根据提供的文件信息,我们可以梳理出以下几个关键知识点: 1. Docker技术概念: Docker是一个开源的应用容器引擎,允许开发者打包他们的应用以及依赖包到一个可移植的容器中,然后发布到任何支持Docker的平台上。容器是完全使用沙箱机制,相互之间不会有任何接口(类似iOS的app)。 2. Docker的使用优势: 使用Docker部署应用可以带来多方面的优势,如提高开发效率、简化部署流程、易于迁移和扩展、强化安全性和隔离性等。容器化应用可以在不同的环境中保持一致的运行状态,减少了"在我的机器上可以运行"这类问题。 3. Compose工具: Docker Compose是一个用来定义和运行多容器Docker应用程序的工具。通过Compose,用户可以使用YAML文件来配置应用程序服务,并通过一个命令,完成容器的创建和启动。Docker Compose使得复杂配置的多容器应用的部署和管理工作变得简单。 4. APM(应用性能管理)服务器: APM服务器是用来监控和管理软件应用性能的工具。它通常包括实时性能监控、问题诊断、性能瓶颈定位、用户体验报告等功能。通过提供深入的应用性能洞察,APM能够帮助开发者和运维人员优化和提升应用性能。 5. 弹性APM服务器: 在标题中提到的“弹性”可能是指APM服务器能够根据应用的性能需求自动调整资源分配。这种弹性服务器可以动态地根据负载情况增加或减少资源,以保证应用性能的稳定,并在必要时节省资源。 6. Docker和Compose在APM服务器部署中的作用: Docker和Compose共同作用于APM服务器的部署,意味着开发者可能通过定义一个Docker Compose文件来指定APM服务器的所有依赖和服务。利用容器化的方式,可以保证APM服务器在开发、测试和生产环境中的部署和运行一致性。 7. “docker-apm-master”文件结构: 文件名称列表中提及的“docker-apm-master”很可能是包含Dockerfile、docker-compose.yml等文件的目录名称,这个目录用于管理和构建弹性APM服务器的Docker镜像和服务。在该目录下,可能包含了用于构建APM服务器镜像的脚本、配置文件,以及用于部署和管理APM服务器的Docker Compose配置。 8. 开发和运维实践: 一个“由Docker和Compose支持的弹性apm服务器”项目体现了现代软件开发和运维的实践,即使用容器化和自动化工具来提升开发效率、简化运维工作以及优化应用部署。在微服务架构和云计算日益普及的今天,这类实践变得越来越普遍。 综合以上知识点,我们可以理解“docker-apm:由Docker和Compose支持的弹性apm服务器”是一个运用现代开发运维技术实践,提供应用性能管理解决方案的项目。它结合了Docker容器化技术和Docker Compose自动化管理工具,以实现一个可扩展、弹性的APM服务器,帮助开发者和运维团队高效地监控和优化应用性能。
recommend-type

游戏开发与部署全流程指南

# 游戏开发与部署全流程指南 ## 1. 开发整体游戏结构 ### 1.1 场景添加与游戏启动 要确保场景能被加载,需将其添加到构建设置中。若不添加,Unity 就无法知晓可用的场景。在之前的测试中,若只是重新加载当前场景,无需进行此操作;但现在若要切换关卡,就必须添加。添加完成后,可从启动场景点击“播放”来启动游戏,此时游戏管理器对象会在两个场景中共享。 不过需注意,由于管理器是在启动场景中加载的,所以必须始终从该场景启动游戏。若觉得每次手动打开启动场景麻烦,可使用此编辑器脚本,它能在点击“播放”时自动切换到指定场景:[https://github.com/jhocking/from-u
recommend-type

初级运维面试题

<think> 首先,用户的问题是:“我想查找初级运维面试题”,这是在查询初级运维岗位的面试题。系统指令要求我参考提供的引用内容,这些引用来自之前的消息。 回顾引用内容: - 引用[1]:是关于运维面试题的文章,提到“2024年9月最新运维高频面试题汇总(1)”,但它是个标题,没有具体题目内容。它宣传了一个群组。 - 引用[2]:是“云计算运维工程师面试题(二)”,列出了11个具体问题,涉及云计算、弹性伸缩、高可用性、安全等。这些不是专门针对初级的,但可能涵盖。 - 引用[3]:是“初级运维工程师面试题”,描述了一个场景:查杀病毒的过程,提到了一个可疑进程。这不是直接的面试题列表,而是
recommend-type

构建Ikiwiki的Docker容器:简易部署与使用

### 知识点概述 #### 标题:“docker-ikiwiki:Ikiwiki的Docker容器” - Docker:一种开源的容器化平台,用于自动化部署、扩展和管理应用程序。 - Ikiwiki:一个使用git作为后端的wiki引擎,其特色在于使用Markdown或Textile等标记语言编辑页面。 - 容器化部署:利用Docker技术进行软件的打包、分发和运行,以容器形式提供一致的运行环境。 #### 描述:“Ikiwiki Docker容器” - Docker映像与使用:介绍了如何通过命令行工具拉取并运行一个Ikiwiki的Docker镜像。 - 拉取Docker镜像:使用命令`docker pull ankitrgadiya/ikiwiki`从Docker Hub中获取预配置好的Ikiwiki容器镜像。 - 使用方式:提供了两种使用该Docker镜像的示例,一种是与域名绑定进行SSL支持的配置,另一种是作为独立运行且不支持SSL的配置。 - 独立映像的局限性:明确指出独立映像不支持SSL,因此推荐与Nginx-Proxy结合使用以获得更好的网络服务。 #### 标签:“docker ikiwiki Shell” - 标签汇总:这些标签提示了该文档内容涉及的技术范畴,即Docker容器技术、Ikiwiki应用以及Shell命令行操作。 - Docker标签:强调了Docker在自动化部署Ikiwiki中的应用。 - Ikiwiki标签:指出了本文内容与Ikiwiki的使用和配置相关。 - Shell标签:表明操作过程涉及到Linux Shell命令的执行。 #### 压缩包子文件的文件名称列表:“docker-ikiwiki-master” - 压缩包内容:该列表暗示了压缩包内包含的文件是以"docker-ikiwiki-master"为名称的主目录或项目文件。 - 文件结构:可能包含了Dockerfile、配置脚本、说明文档等文件,用于构建和运行Ikiwiki Docker容器。 ### 详细知识点 #### Docker容器技术 - Docker基础:Docker是一个开源的应用容器引擎,允许开发者打包他们的应用以及应用的依赖包到一个可移植的容器中,然后发布到任何流行的Linux机器上,也可以实现虚拟化。容器是完全使用沙箱机制,相互之间不会有任何接口(类似 iPhone 的 app)。 - 镜像与容器:在Docker中,镜像(Image)是一个可执行包,包含了运行应用程序所需的所有内容,例如代码、运行时、库、环境变量和配置文件。容器(Container)是从镜像创建的应用运行实例,可以进行启动、停止、删除等操作。每个容器都是相互隔离的,保证应用安全运行。 #### Ikiwiki的配置与部署 - Ikiwiki简介:Ikiwiki是一个用git作为后端的wiki引擎,它允许通过文本文件来编辑网页,支持Markdown、Textile等标记语言,使得内容的编写更加直观和方便。 - 部署要求:部署Ikiwiki通常需要一个web服务器和一些配置来处理HTTP请求。而通过Docker,用户可以快速部署一个预配置好的Ikiwiki环境。 - 配置方式:Docker运行命令中涉及到了多个参数的使用,如`--name`用于给容器命名,`-v`用于指定挂载卷,`-e`用于设置环境变量,`-p`用于端口映射,`-d`用于让容器在后台运行。 #### Docker命令行操作 - docker pull:从Docker Hub或用户指定的仓库拉取指定的镜像。 - docker run:创建一个新的容器并运行一个命令。这里提供了两种运行Ikiwiki的方式,一种是用于生产环境的,与域名绑定并支持SSL;另一种是用于开发或测试环境的,直接在80端口运行。 #### 网络代理和SSL支持 - SSL支持:SSL(Secure Sockets Layer)是一种安全协议,用于保障Web服务器和浏览器之间的通信安全。当容器配置为不支持SSL时,通常意味着不直接处理HTTPS请求。 - Nginx-Proxy:一个Docker镜像,用于运行一个Nginx服务器,充当SSL终止层,将SSL终止在Nginx代理中,然后将非加密的HTTP请求转发到后端的容器。这样可以利用Nginx强大的网络功能来处理HTTPS、HTTP/2等,增强系统的安全性和效率。 ### 总结 在介绍如何部署Ikiwiki wiki引擎到Docker容器的过程中,涉及到了Docker的基本概念、容器的创建和配置、Ikiwiki的运行机制以及Shell命令行的实用操作。文档也提到了在使用不支持SSL的独立容器时,推荐配合Nginx-Proxy来增强安全性和扩展性。这些知识点对于管理和维护Docker容器化的应用具有很高的实用价值。
recommend-type

Unity开发实用指南:快捷键、外部工具与模型创建

### Unity开发实用指南:快捷键、外部工具与模型创建 #### 1. Unity场景导航与键盘快捷键 在使用Unity进行开发时,一个三键鼠标会带来更好的操作体验,虽然Unity也支持单键或双键鼠标,但三键鼠标能让操作更加便捷,在Mac系统上同样适用。 除了使用鼠标进行导航操作外,键盘也能实现一些视图控制功能。当按住鼠标右键时,可以使用键盘上的W、A、S、D键像在第一人称游戏中一样移动视角。在进行其他操作时按住Shift键可以加快移动速度。 而在选择对象后按下F键,场景视图会自动平移和缩放以聚焦该对象。如果在场景导航中迷失方向,可以在层级面板中选择一个对象,将鼠标移到场景视图上(此