要用简单的Python示例来理解大语言模型（LLMs）是如何工作的，可以从以下几个基本概念开始：词嵌入（Word Embeddings）、序列建模和生成文本。我们可以逐步构建一个非常简单的语言模型来演示这些概念。

1. 词嵌入（Word Embeddings）

词嵌入是将单词转换为向量表示，使得相似的单词在向量空间中更接近。我们可以使用Python中的gensim库来生成简单的词嵌入。

import gensim.downloader as api

# 下载预训练的词嵌入模型
word_vectors = api.load("glove-wiki-gigaword-50")

# 查找一个单词的嵌入向量
vector = word_vectors['king']
print(vector)

# 找到最相似的词
similar_words = word_vectors.most_similar('king')
print(similar_words)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
2. 序列建模

序列建模是指模型学习如何从一系列输入中预测下一个单词。我们可以用一个简单的基于字符的模型来演示这个过程。

import numpy as np
import random

# 准备简单的训练数据
text = "hello world"
chars = list(set(text))
char_indices = {c: i for i, c in enumerate(chars)}
indices_char = {i: c for i, c in enumerate(chars)}

# 创建输入和输出序列
maxlen = 3
step = 1
sentences = []
next_chars = []
for i in range(0, len(text) - maxlen, step):
    sentences.append(text[i: i + maxlen])
    next_chars.append(text[i + maxlen])
print('训练样本:', sentences)
print('下一个字符:', next_chars)

# 向量化
X = np.zeros((len(sentences), maxlen, len(chars)), dtype=np.bool)
y = np.zeros((len(sentences), len(chars)), dtype=np.bool)
for i, sentence in enumerate(sentences):
    for t, char in enumerate(sentence):
        X[i, t, char_indices[char]] = 1
    y[i, char_indices[next_chars[i]]] = 1
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
3. 简单的RNN模型

使用Keras构建一个简单的RNN模型来学习这些序列。

from keras.models import Sequential
from keras.layers import LSTM, Dense

model = Sequential()
model.add(LSTM(128, input_shape=(maxlen, len(chars))))
model.add(Dense(len(chars), activation='softmax'))

model.compile(loss='categorical_crossentropy', optimizer='adam')

# 训练模型
model.fit(X, y, batch_size=128, epochs=10)
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
4. 生成文本

使用训练好的模型生成新的文本。

# 随机选择一个初始文本
start_index = random.randint(0, len(text) - maxlen - 1)
generated_text = text[start_index: start_index + maxlen]
print('生成初始文本:', generated_text)

# 生成字符
for i in range(50):
    sampled = np.zeros((1, maxlen, len(chars)))
    for t, char in enumerate(generated_text):
        sampled[0, t, char_indices[char]] = 1

    preds = model.predict(sampled, verbose=0)[0]
    next_index = np.argmax(preds)
    next_char = indices_char[next_index]

    generated_text += next_char
    generated_text = generated_text[1:]

    print(next_char, end='')
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
总结

通过这些步骤，我们用Python和简单的RNN模型展示了LLMs的基本工作原理。虽然实际的LLMs（如GPT-3）要复杂得多，但核心思想仍然类似：从大量数据中学习语言模式，并利用这些模式生成新的文本。