import torch
import torch.nn as nn
import torch.optim as optim
#導入訓練模型
text = ""
#將text中的字數轉換成數字
chars = list(set(text))
#建立labels，用以儲存不同的句子
labels = [""]
int2label = dict(enumerate(labels))
label2int = {label: index for index, label in int2label.items()}
encoded_labels = [label2int[label] for label in labels]
int2char = dict(enumerate(chars))
char2int = {char: index for index, char in int2char.items()}
encoded_text = [char2int[char] for char in text]
#定義訓練環境
class SentenceRecognitionModel(nn.Module):
    def __init__(self, vocab_size, embedding_dim, hidden_dim, num_layers,num_classes):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size,embedding_dim)
        self.lstm = nn.LSTM(embedding_dim,hidden_dim, num_layers)
        self.fc = nn.Linear(hidden_dim, num_classes)
    def forward(self, x):
        x = self.embedding(x)
        x = self.fc(x)
        return x
#創建模型
model = SentenceRecognitionModel(len(chars),embedding_dim = 256, hidden_dim = 64, num_layers =     2, num_classes=len(labels))
#創建優化器
optimizer = optim.Adam(model.parameters())
#紀錄模型訓練損耗
loss_fn = nn.CrossEntropyLoss()
#訓練模型
num_epochs = 25000 #訓練二萬五千次模型
for epoch in range(num_epochs):
    #將每一次訓練前的梯度設為零，這樣在下次迭代時就不會衝突到了
    optimizer.zero_grad()
    input_seq = torch.tensor(encoded_text).unsqueeze(0)
    target_label = torch.tensor(encoded_labels).unsqueeze(0)
    output = model(input_seq)
    loss = loss_fn(output.squeeze(), target_label.squeeze())
    loss.backward()
    optimizer.step()
    if (epoch+1) % 10 == 0:
    print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
#將模型設為推理模式，以讓模型的輸出保持一致
model.eval()
while True:
  # 接收用戶輸入的句子
  input_sentence = input("請輸入句子：")
  if input_sentence not in labels:
    print("輸入的句子不存在於訓練數據中")
  else:
    start_index = label2int[input_sentence]
    generated_text = int2char[start_index]
    # 選擇要生成的文本長度
    num_generated = 100
    # 對輸入的句子進行預處理，將其編碼為數字
    encoded_sentence = [label2int[start_index] for generated_text in input_sentence]
    input_seq = torch.tensor(encoded_sentence).unsqueeze(0)
    # 將輸入的句子傳遞到模型中
 
    with torch.no_grad():
        output = model(input_seq)
    #使用模型去辨識句子
    output_idx = torch.argmax(output.squeeze()).item()
    recognized_label = int2label[output_idx]
# 輸出結果
print(f"Recognized Label: {recognized_label}")
FILE = 'model_state_dict.pt'
model.save(model.state_dict(), 'SentenceRecognizedModel.pt')    

encoded_sentence = [label2int[start_index] for generated_text in input_sentence]
input_seq = torch.tensor(encoded_sentence).unsqueeze(0)

 encoded_sentence = [label2int[start_index] for generated_text in input_sentence]

encoded_sentence = [start_index]