import torch
import torch.nn as nn
# 基本使用示例
embedding = nn.Embedding(num_embeddings=10, embedding_dim=5)
# num_embeddings: 詞匯表大小
# embedding_dim: 詞向量維度
input = torch.LongTensor([1, 2, 3])  # 3個詞的索引
output = embedding(input)
print(output.shape)  # torch.Size([3, 5])

torch.nn.Embedding(
    num_embeddings, 
    embedding_dim, 
    padding_idx=None,
    max_norm=None, 
    norm_type=2.0,
    scale_grad_by_freq=False, 
    sparse=False,
    _weight=None,
    _freeze=False,
    device=None,
    dtype=None
)

# 隨機初始化
embedding = nn.Embedding(100, 50)  # 100個詞，每個詞50維
# 使用預(yù)訓(xùn)練詞向量
pretrained_weights = torch.randn(100, 50)  # 模擬預(yù)訓(xùn)練權(quán)重
embedding = nn.Embedding.from_pretrained(pretrained_weights)

embedding = nn.Embedding(100, 50, padding_idx=0)
# 假設(shè)0是padding的索引
input = torch.LongTensor([[1, 2, 3, 0], [4, 5, 0, 0]])  # batch_size=2, seq_len=4
output = embedding(input)
print(output.shape)  # torch.Size([2, 4, 50])

import torch
import torch.nn as nn
class TextClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_classes):
        super(TextClassifier, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.fc = nn.Linear(embed_dim, num_classes)
    def forward(self, x):
        # x shape: (batch_size, seq_len)
        embedded = self.embedding(x)  # (batch_size, seq_len, embed_dim)
        # 取序列中所有詞向量的平均值
        pooled = embedded.mean(dim=1)  # (batch_size, embed_dim)
        out = self.fc(pooled)
        return out
# 使用示例
model = TextClassifier(vocab_size=10000, embed_dim=300, num_classes=5)
input = torch.LongTensor([[1, 2, 3], [4, 5, 0]])  # batch_size=2, seq_len=3
output = model(input)
print(output.shape)  # torch.Size([2, 5])

class LSTMModel(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_layers, num_classes):
        super(LSTMModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.lstm = nn.LSTM(embed_dim, hidden_dim, num_layers, batch_first=True)
        self.fc = nn.Linear(hidden_dim, num_classes)
    def forward(self, x):
        # x shape: (batch_size, seq_len)
        embedded = self.embedding(x)  # (batch_size, seq_len, embed_dim)
        lstm_out, (h_n, c_n) = self.lstm(embedded)  # lstm_out: (batch_size, seq_len, hidden_dim)
        # 取最后一個時間步的輸出
        out = self.fc(lstm_out[:, -1, :])
        return out
# 使用示例
model = LSTMModel(vocab_size=10000, embed_dim=300, hidden_dim=128, 
                 num_layers=2, num_classes=5)
input = torch.LongTensor([[1, 2, 3, 4], [5, 6, 0, 0]])  # batch_size=2, seq_len=4
output = model(input)
print(output.shape)  # torch.Size([2, 5])

import matplotlib.pyplot as plt
from sklearn.manifold import TSNE
def visualize_embeddings(embedding_layer, word_to_idx, words):
    # 獲取詞向量
    indices = torch.LongTensor([word_to_idx[word] for word in words])
    vectors = embedding_layer(indices).detach().numpy()
    # 使用t-SNE降維
    tsne = TSNE(n_components=2, random_state=42)
    vectors_2d = tsne.fit_transform(vectors)
    # 可視化
    plt.figure(figsize=(10, 8))
    for i, word in enumerate(words):
        plt.scatter(vectors_2d[i, 0], vectors_2d[i, 1])
        plt.annotate(word, xy=(vectors_2d[i, 0], vectors_2d[i, 1]))
    plt.show()
# 示例詞匯
words = ["king", "queen", "man", "woman", "computer", "data"]
word_to_idx = {word: i for i, word in enumerate(words)}
# 創(chuàng)建嵌入層
embedding = nn.Embedding(len(words), 50)
# 可視化
visualize_embeddings(embedding, word_to_idx, words)

# 凍結(jié)嵌入層參數(shù)(不更新)
embedding = nn.Embedding(1000, 300)
embedding.weight.requires_grad = False
# 或者使用from_pretrained時直接凍結(jié)
pretrained = torch.randn(1000, 300)
embedding = nn.Embedding.from_pretrained(pretrained, freeze=True)

# 方法1: 使用UNK token
vocab = {"<UNK>": 0, ...}  # 將未知詞映射到0
embedding = nn.Embedding(len(vocab), 300, padding_idx=0)
# 方法2: 隨機初始化
unk_vector = torch.randn(300)  # 為OOV詞準(zhǔn)備的特殊向量

def load_pretrained_embeddings(word_to_idx, embedding_file, embedding_dim):
    # 創(chuàng)建權(quán)重矩陣
    embedding_matrix = torch.zeros(len(word_to_idx), embedding_dim)
    # 加載預(yù)訓(xùn)練詞向量(這里以GloVe格式為例)
    with open(embedding_file, 'r', encoding='utf-8') as f:
        for line in f:
            values = line.split()
            word = values[0]
            if word in word_to_idx:
                idx = word_to_idx[word]
                vector = torch.tensor([float(val) for val in values[1:]])
                embedding_matrix[idx] = vector
    return nn.Embedding.from_pretrained(embedding_matrix)
# 使用示例
word_to_idx = {"hello": 0, "world": 1, ...}  # 你的詞匯表
embedding = load_pretrained_embeddings(word_to_idx, 'glove.6B.100d.txt', 100)

embedding = nn.Embedding.from_pretrained(pretrained_weights, freeze=False)  # 設(shè)置freeze=False