1
2
3
4
5
6

import torch

# 假设 hidden_states 是模型的输出，形状为 (batch_size, sequence_length, hidden_size)
hidden_states = torch.randn(2, 10, 768)
pooled_output = torch.mean(hidden_states, dim=1)  # 在序列长度维度上求平均
print(pooled_output.shape)  # 输出: torch.Size([2, 768])

1
2
3
4
5
6

import torch

# 假设 hidden_states 是模型的输出，形状为 (batch_size, sequence_length, hidden_size)
hidden_states = torch.randn(2, 10, 768)
pooled_output, _ = torch.max(hidden_states, dim=1)  # 在序列长度维度上取最大值
print(pooled_output.shape)  # 输出: torch.Size([2, 768])

1
2
3
4
5
6

import torch

# 假设 hidden_states 是模型的输出，形状为 (batch_size, sequence_length, hidden_size)
hidden_states = torch.randn(2, 10, 768)
pooled_output = hidden_states[:, 0, :]  # 选取每个样本的第一个向量
print(pooled_output.shape)  # 输出: torch.Size([2, 768])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import torch

# 假设 hidden_states 是模型的输出，形状为 (batch_size, sequence_length, hidden_size)
hidden_states = torch.randn(2, 10, 768)
# 假设 weights 是每个向量的权重，形状为 (batch_size, sequence_length)
weights = torch.rand(2, 10)
weights = torch.softmax(weights, dim=1)  # 确保权重和为 1
weighted_hidden_states = hidden_states * weights.unsqueeze(-1)
pooled_output = torch.sum(weighted_hidden_states, dim=1)
print(pooled_output.shape)  # 输出: torch.Size([2, 768])

1
2
3
4
5
6

import torch

# 假设 hidden_states 是模型的输出，形状为 (batch_size, sequence_length, hidden_size)
hidden_states = torch.randn(2, 10, 768)
pooled_output = hidden_states[:, -1, :]  # 选取每个样本的最后一个向量
print(pooled_output.shape)  # 输出: torch.Size([2, 768])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

from transformers import AutoModel, AutoTokenizer
import torch

model_name = "bert-base-uncased" 
model = AutoModel.from_pretrained(model_name,device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

question = "Hugging Face is creating a tool that democratizes AI."
inputs = tokenizer(question,padding=True,return_tensors='pt').to(model.device)

outputs = model(**inputs)
last_hidden_state = outputs.last_hidden_state  # 获取模型的最后一层隐藏状态

print("Last hidden state shape:", last_hidden_state.shape)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "gpt2"
model = AutoModelForCausalLM.from_pretrained(model_name,device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

question = "Hugging Face is creating a tool that democratizes AI."
inputs = tokenizer(question,padding=True,return_tensors='pt').to(model.device)

output = model.generate(
    **inputs,              # 输入ID（token化后的文本）
    max_length=50,         # 生成的最大长度
    num_return_sequences=1,  # 返回生成的序列数
    no_repeat_ngram_size=2,  # 防止生成重复的n-gram
    temperature=0.7,        # 温度（控制随机性,值越大越具创造性）
    top_k=50,               # 只考虑前k个最可能的词
    top_p=0.95,             # 采用 nucleus sampling（前p%的词）
    do_sample=True          # 启用采样（避免确定性输出）
)
generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
print(generated_text)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from transformers import AutoModelForSequenceClassification, AutoTokenizer
import torch

model_name = "bert-base-uncased" 
# 假设是二分类任务
model = AutoModelForSequenceClassification.from_pretrained(model_name,device_map="auto",num_labels=2)
tokenizer = AutoTokenizer.from_pretrained(model_name)

question = "Hugging Face is creating a tool that democratizes AI."
inputs = tokenizer(question,padding=True,return_tensors='pt').to(model.device)

# 前向传播
outputs = model(**inputs)
logits = outputs.logits  # 获取分类任务的输出logits

print("Logits:", logits)
print(outputs.logits.shape)    # 查看输出形状

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

from transformers import AutoModelForTokenClassification, AutoTokenizer
import torch

model_name = "bert-base-uncased" 
model = AutoModelForTokenClassification.from_pretrained(model_name,device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

question = "Hugging Face is creating a tool that democratizes AI."
inputs = tokenizer(question,padding=True,return_tensors='pt').to(model.device)

# 前向传播
outputs = model(**inputs)
logits_token_class = outputs.logits  # 获取每个token的分类结果

print("Token classification logits:", logits_token_class.shape)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from transformers import AutoModelForQuestionAnswering, AutoTokenizer
import torch

model_name = "distilbert-base-uncased-distilled-squad"
model = AutoModelForQuestionAnswering.from_pretrained(model_name,device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

question = "What is the capital of France?"
context = "France is a country in Europe. Paris is its capital and the largest city."
inputs = tokenizer(question, context, return_tensors="pt").to(model.device)

# `start_logits` 和 `end_logits` 分别表示答案的起始和结束位置
with torch.no_grad():
    outputs = model(**inputs)
start_position = torch.argmax(outputs.start_logits)  # 答案起始位置
end_position = torch.argmax(outputs.end_logits)      # 答案结束位置

# 7. 解码答案
answer = tokenizer.convert_tokens_to_string(
    tokenizer.convert_ids_to_tokens(inputs['input_ids'][0][start_position:end_position+1])
)
print("Question:", question)
print("Answer:", answer)

1
2
3
4
5

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("all-mpnet-base-v2")
embedding = model.encode("This is a test")
print(embedding.shape)  # e.g. [768]