算法金 | LSTM 原作者带队，一个强大的算法模型杀回来了

import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import LSTM, Dense
from keras.preprocessing.sequence import pad_sequences

# 生成武侠元素的数据集
def generate_data(num_sequences, sequence_length):
    data = []
    for _ in range(num_sequences):
        sequence = np.random.choice(['少林', '武当', '峨眉', '华山', '昆仑'], size=sequence_length)
        data.append(sequence)
    return data

# 将文本数据转换为数字
def text_to_numeric(data):
    mapping = {'少林': 0, '武当': 1, '峨眉': 2, '华山': 3, '昆仑': 4}
    numeric_data = []
    for sequence in data:
        numeric_data.append([mapping[item] for item in sequence])
    return numeric_data

# 数据集生成
data = generate_data(1000, 10)
numeric_data = text_to_numeric(data)

# 填充序列
X = pad_sequences(numeric_data, maxlen=10)
y = np.random.rand(1000, 1)  # 随机生成一些标签

# 构建 LSTM 模型
model = Sequential()
model.add(LSTM(50, input_shape=(10, 1)))
model.add(Dense(1))
model.compile(loss='mse', optimizer='adam')

# 训练模型
model.fit(X, y, epochs=10, batch_size=32)

# 可视化训练结果
loss = model.history.history['loss']
plt.plot(loss)
plt.title('Model Loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.show()

import numpy as np
from keras.models import Sequential
from keras.layers import LSTM, Dense, Embedding
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences

# 生成武侠文本数据集
texts = [
    "少林武当峨眉华山昆仑",
    "武当少林昆仑华山峨眉",
    "峨眉少林华山昆仑武当",
    "昆仑峨眉少林武当华山",
    "华山昆仑峨眉少林武当"
]

# 创建文本 Tokenizer
tokenizer = Tokenizer(char_level=True)
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
vocab_size = len(tokenizer.word_index) + 1

# 准备数据
X, y = [], []
for sequence in sequences:
    for i in range(1, len(sequence)):
        X.append(sequence[:i])
        y.append(sequence[i])
X = pad_sequences(X, maxlen=10)
y = np.array(y)

# 构建 LSTM 模型
model = Sequential()
model.add(Embedding(vocab_size, 50, input_length=10))
model.add(LSTM(100))
model.add(Dense(vocab_size, activation='softmax'))
model.compile(loss='sparse_categorical_crossentropy', optimizer='adam')

# 训练模型
model.fit(X, y, epochs=200, verbose=2)

# 文本生成函数
def generate_text(model, tokenizer, seed_text, n_chars):
    result = seed_text
    for _ in range(n_chars):
        encoded = tokenizer.texts_to_sequences([seed_text])[0]
        encoded = pad_sequences([encoded], maxlen=10, truncating='pre')
        predicted = np.argmax(model.predict(encoded), axis=-1)
        out_char = tokenizer.index_word[predicted[0]]
        seed_text += out_char
        result += out_char
    return result

# 生成新文本
seed_text = "少林"
generated_text = generate_text(model, tokenizer, seed_text, 20)
print(generated_text)

import numpy as np
import matplotlib.pyplot as plt
from keras.models import Sequential
from keras.layers import LSTM, Dense

# 生成模拟时间序列数据
np.random.seed(7)
data = np.sin(np.linspace(0, 50, 500)) + np.random.normal(0, 0.1, 500)
sequence_length = 10

# 准备数据
X = []
y = []
for i in range(len(data) - sequence_length):
    X.append(data[i:i+sequence_length])
    y.append(data[i+sequence_length])
X = np.array(X)
y = np.array(y)

# 调整数据形状
X = np.reshape(X, (X.shape[0], X.shape[1], 1))

# 构建 LSTM 模型
model = Sequential()
model.add(LSTM(50, input_shape=(sequence_length, 1)))
model.add(Dense(1))
model.compile(loss='mse', optimizer='adam')

# 训练模型
model.fit(X, y, epochs=20, batch_size=32, verbose=2)

# 预测结果
predicted = model.predict(X)

# 可视化结果
plt.plot(data, label='真实数据')
plt.plot(np.arange(sequence_length, sequence_length + len(predicted)), predicted, label='预测数据')
plt.legend()
plt.show()