自然语言处理疑问
import reimport string
# Cleaning Functions
def remove_tag(text):
tag = re.compile(r'@\S+')#匹配连续字符
return tag.sub(r'',text)#使用sub函数用空串替换
def remove_URL(text):
# http:... / https:... / www... #匹配网页链接
url = re.compile(r'https?://\S+|www\.\S+')
return re.sub(url,'',text)
def remove_html(text):#匹配特殊符号
# < > / ( )
html = re.compile(r'<[^>]+>|\([^)]+\)')
return html.sub(r'',text)
def remove_punct(text):
# ['!','"','$','%','&',"'",'(',')','*',
# '+',',','-','.','/',':',';','<','=',
# '>','?','@','[','\\',']','^','_','`',
# '{','|','}','~']
punctuations = list(string.punctuation)
table = str.maketrans('', '', ''.join(punctuations))
return text.translate(table)
其中，r'@\S+'是什么意思 `r'@\S+'` 是一个正则表达式，用于匹配以 `@` 开头的连续非空白字符序列。它通常用于去除像 Twitter 或社交媒体平台上的用户标签（例如 `@username`）。
- `@` 匹配字符 `@`。
- `\S` 匹配任何非空白字符（相当于 `[^ \t\n\r\f\v]`）。
- `+` 表示前面的模式可以重复一次或多次。
因此，`r'@\S+'` 可以匹配一个 `@` 符号后面跟随的一个或多个非空白字符，等效于提取并移除诸如 `@username` 这样的用户标签。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 FishC 发表于 2024-10-30 23:50
`r'@\S+'` 是一个正则表达式，用于匹配以 `@` 开头的连续非空白字符序列。它通常用于去除像 Twitter 或社交 ...
text.translate(table)
这个语句表示什么意思 Terence888 发表于 2024-10-30 23:51
text.translate(table)
这个语句表示什么意思
`text.translate(table)` 是用来处理字符串的，该语法用于替换字符串中的字符。具体来说，这里 `table` 是通过 `str.maketrans()` 函数生成的一个翻译映射表，用于指定每个字符的替换规则。
在你提供的函数 `remove_punct(text)` 中，`table` 是生成用来去除标点符号的映射表。`str.maketrans('', '', ''.join(punctuations))` 创建了一个转换映射，其中所有在 `punctuations` 列表中的字符都会被替换为空字符（即被删除）。
因此，`text.translate(table)` 会遍历 `text` 中的每一个字符，如果这个字符在 `table` 中存在对应的替换（在这个例子中，被替换成空字符），就进行替换，最终返回一个去除了标点符号的字符串。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 FishC 发表于 2024-10-30 23:51
`text.translate(table)` 是用来处理字符串的，该语法用于替换字符串中的字符。具体来说，这里 `table` ...
from torch.utils.data import Dataset
import torch
class TweetDataset(Dataset):
def __init__(self,df,is_grad,tokenizer):
self.df = df # Pandas.DataFrame
self.is_grad = is_grad # True: train,valid / False: test
self.tokenizer = tokenizer
def __len__(self):
return len(self.df) # number of samples
def __getitem__(self,idx):
text = self.df.loc['text'] # extracting text from each row
encoded_dict = self.tokenizer.encode_plus(
text,
add_special_tokens=True,#自动在每个文本前后添加特殊标记(如CLS和SEP)
padding='max_length',#补0
truncation=True,#句子长度大于max_length时截断
max_length=84, # given to the max_length of tokenized text
return_tensors='pt', # PyTorch
return_attention_mask=True, # We should put it into the model
)
if self.is_grad:
labels = self.df.loc['target']
# ->
return {'input_ids':encoded_dict['input_ids'].squeeze(),
'attention_mask':encoded_dict['attention_mask'].squeeze(),
# Our loss_fn wants it to be a "float" type
'labels':torch.tensor(labels,dtype=torch.float).unsqueeze(dim=0)}
else:
# ->
return {'input_ids':encoded_dict['input_ids'].squeeze(),
'attention_mask':encoded_dict['attention_mask'].squeeze()}
上述代码中，编码器的参数return_attention_mask=True表示什么意思 Terence888 发表于 2024-10-31 00:08
from torch.utils.data import Dataset
import torch ...
在自然语言处理中，我们经常需要对文本进行填充和截断，以使得所有输入的序列具有相同的长度。当输入序列经过填充（padding）或截断（truncation）处理后，我们需要知道哪些部分是真实的文本，哪些部分是为了调整长度而添加的填充。
`tokenizer.encode_plus()` 函数中的 `return_attention_mask=True` 参数用于生成一个attention mask。attention mask是一个与输入序列长度相同的二进制矩阵，其中：
- `1` 表示实际的文本标记（token）。
- `0` 表示填充值（padding）。
通过这个mask，模型可以在处理填充的输入序列时忽略填充的部分，从而提高效率并确保模型只注意实际的文本内容。
例如，如果你的最大序列长度是8，而输入的文本序列长度是5，那么填充后的序列可能是这样：
相应的 `attention_mask` 就会是：
这个 `attention_mask` 告诉模型在计算注意力（attention）时忽略那些填充值（即值为0的部分）。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 FishC 发表于 2024-10-31 00:19
在自然语言处理中，我们经常需要对文本进行填充和截断，以使得所有输入的序列具有相同的长度。当输入序 ...
import numpy as np
import torch
import torch.nn as nn
from transformers import BertForSequenceClassification
# Never Detach Tensor during forward
class TweetsModel(nn.Module):
'''
To be honest, under the setting like this, there is no need to inherit.
It's because I used "BertForSequenceClassification" which has final layer
that is composed of "hidden size 2" for binary classification.
So, you can think of this unnecessary inheritance is kind of "practice" for myself :)
'''
def __init__(self,model_name):
super().__init__()
self.model = BertForSequenceClassification.from_pretrained(model_name)#from_pretrained方法会加载相应的预训练模型权重
def forward(self,input_ids,attention_mask):
output = self.model(input_ids=input_ids,attention_mask=attention_mask)
logits = output.logits
return logits
最后一行logits是计算什么的 Terence888 发表于 2024-10-31 10:38
import numpy as np
import torch
import torch.nn...
在这段代码中，`logits` 是模型的输出，表示未经过激活函数处理的原始预测值。具体来说：
- `BertForSequenceClassification` 是一个用于序列分类任务的预训练 BERT 模型。它的最后一层是一个线性层，用于将 BERT 的输出转换为分类任务的输出。
- `logits` 是这个线性层的输出，通常用于二分类或多分类任务。在二分类任务中，`logits` 通常包含两个值，分别对应于两个类别的分数。
- 这些分数可以通过激活函数（如 softmax）转换为概率，用于最终的分类决策。
在训练过程中，`logits` 通常会被传递给损失函数（如交叉熵损失），以计算模型的损失并进行反向传播。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。 FishC 发表于 2024-10-31 10:38
在这段代码中，`logits` 是模型的输出，表示未经过激活函数处理的原始预测值。具体来说：
- `BertFo ...
# optimizer
from transformers import AdamW
optimizer = AdamW(model.parameters(),
lr=6e-6,
eps=1e-8,
no_deprecation_warning=True)
上述是不是gpt模型？优化器最后一个参数 no_deprecation_warning=True表示什么意思 Terence888 发表于 2024-10-31 10:50
上述是不是gpt模型？优化器最后一个参数表示什么意思
可以自己查 FishC 发表于 2024-10-31 10:38
在这段代码中，`logits` 是模型的输出，表示未经过激活函数处理的原始预测值。具体来说：
- `BertFo ...
import gc,os
from tqdm.auto import tqdm # visualizing tool for progress
# They will be used to pick the best model.pt given to the valid loss
best_model_epoch, valid_loss_values = [],[]
valid_loss_min = # arbitrary loss I set here
def train(model,device,train_dataloader,valid_dataloader,epochs,loss_fn,optimizer,metric):
for epoch in range(epochs):
gc.collect() # memory cleaning垃圾回收机制，减少占用内存
model.train()
train_loss = 0
train_step = 0
pbar = tqdm(train_dataloader)#tqdm参数是一个iterable
for batch in pbar: # you can also write like "for batch in tqdm(train_dataloader"
optimizer.zero_grad() # initialize
train_step += 1
train_input_ids = batch['input_ids'].to(device)
train_attention_mask = batch['attention_mask'].to(device)
train_labels = batch['labels'].squeeze().to(device).long()
# You can refer to the class "TweetsModel" for understand
# what would be logits
logits = model(train_input_ids, train_attention_mask).to(device)
predictions = torch.argmax(logits, dim=1) # get an index from larger one
detached_predictions = predictions.detach().cpu().numpy()
loss = loss_fn(logits, train_labels)
loss.backward()
optimizer.step()
model.zero_grad()
train_loss += loss.detach().cpu().numpy().item()
pbar.set_postfix({'train_loss':train_loss/train_step})
pbar.close()
with torch.no_grad():
model.eval()
valid_loss = 0
valid_step = 0
total_valid_score = 0
y_pred = [] # for getting f1_score that is a metric of the competition
y_true = []
pbar = tqdm(valid_dataloader)
for batch in pbar:
valid_step += 1
valid_input_ids = batch['input_ids'].to(device)
valid_attention_mask = batch['attention_mask'].to(device)
valid_labels = batch['labels'].squeeze().to(device).long()
logits = model(valid_input_ids, valid_attention_mask).to(device)
predictions = torch.argmax(logits, dim=1)
detached_predictions = predictions.detach().cpu().numpy()
loss = loss_fn(logits, valid_labels)
valid_loss += loss.detach().cpu().numpy().item()
y_pred.extend(predictions.cpu().numpy())
y_true.extend(valid_labels.cpu().numpy())
valid_loss /= valid_step
f1 = f1_score(y_true,y_pred)
print(f'Epoch [{epoch+1}/{epochs}] Score: {f1}')
print(f'Epoch [{epoch+1}/{epochs}] Valid_loss: {valid_loss}')
if valid_loss < min(valid_loss_min):
print('model improved!')
else:
print('model not improved')
torch.save(model.state_dict(), f'epoch:{epoch+1}_model.pt')
print('save checkpoint!')
valid_loss_min.append(valid_loss)
print(f'valid_loss_min:{min(valid_loss_min)}')
best_model_epoch.append(f'/kaggle/working/epoch:{epoch+1}_model.pt')
valid_loss_values.append(valid_loss)
print('='*100)
select_best_model() # refer to below function
print('Train/Valid Completed!!')
del train_dataloader, valid_dataloader # memory cleaning
gc.collect()
def select_best_model():
best_model = best_model_epoch
os.rename(best_model, best_model.split('.pt') + '_best.pt')
其中最后一行不理解os.rename(best_model, best_model.split('.pt') + '_best.pt') Terence888 发表于 2024-10-31 20:56
import gc,os
from tqdm.auto import tqdm # visuali ...
在代码的最后一行 `os.rename(best_model, best_model.split('.pt') + '_best.pt')` 中，`os.rename` 函数用于重命名文件或目录。
然而，这行代码有一些问题：
1. `best_model` 是一个列表（`best_model_epoch`），而不是一个字符串。`os.rename` 需要两个字符串参数：源文件名和目标文件名。
2. `best_model.split('.pt')` 试图对列表进行字符串操作，这是不正确的。
3. `split('.pt')` 返回一个列表，因此 `+ '_best.pt'` 也会导致错误。
要修复这段代码，首先需要确保 `best_model` 是一个字符串，代表要重命名的文件路径。假设 `best_model_epoch` 中存储的是文件路径的字符串列表，代码应该如下：
def select_best_model():
best_model = best_model_epoch[-1]# 假设最后一个是最好的模型
new_name = best_model.replace('.pt', '_best.pt')
os.rename(best_model, new_name)
这样，`best_model` 是一个字符串，`replace` 方法用于生成新的文件名，并且 `os.rename` 可以正确执行重命名操作。
以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。
页:
[1]