Découvrez comment l'AIGC est utilisé dans la création de paroles

AIGC est une technologie de génération de texte basée sur l'apprentissage profond qui est capable de générer du texte avec une exactitude grammaticale et une cohérence contextuelle. En termes de création de paroles, AIGC peut être utilisé comme un outil de création auxiliaire pour fournir aux créateurs des idées, de l'inspiration et même des paroles entières. Cet article expliquera comment utiliser AIGC pour générer des paroles et fournira du code Python et des explications détaillées.

Étape 1 : Préparez l'ensemble de données

Tout d'abord, nous avons besoin d'un ensemble de données de paroles. Cet ensemble de données peut être constitué de paroles de chansons de votre choix. Vous pouvez les trouver compilées sur Internet ou les organiser vous-même. Ici, nous utiliserons un ensemble de données contenant 200 paroles de chansons anglaises.

Étape 2 : Prétraitement des données

Pour prétraiter les données, nous devons d'abord lire l'ensemble de données dans le programme. Ensuite, nous combinons toutes les paroles en une seule longue chaîne. Ensuite, nous convertissons tous les caractères en minuscules et supprimons tous les signes de ponctuation et caractères spéciaux, ne laissant que les lettres et les espaces. Pour accomplir ces opérations, nous pouvons utiliser des méthodes de chaîne et des expressions régulières en Python.

import re

def preprocess(text):
    # 将所有字符转换为小写字母
    text = text.lower()
    # 去除标点符号和特殊字符
    text = re.sub(r"[^a-zA-Z\s]", "", text)
    # 返回处理后的文本
    return text

# 读取数据集
with open("lyrics_dataset.txt", "r") as f:
    lyrics = f.read()

# 处理数据集
lyrics = preprocess(lyrics)

# 打印处理后的数据集
print(lyrics[:100])

Étape 3 : Entraîner le modèle

Ensuite, nous devons utiliser AIGC pour entraîner un modèle qui génère des paroles. Ici, nous utiliserons TensorFlow et Keras pour créer le modèle. Tout d’abord, nous devons convertir l’ensemble de données en une séquence de nombres, ce qui peut être fait en mappant chaque caractère à un nombre unique. Nous devons également définir la structure et les hyperparamètres du modèle, tels que la longueur de la séquence, la dimension d'intégration, le nombre de couches LSTM, le nombre d'unités LSTM, etc.

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, LSTM, Embedding

# 将字符映射到数字
chars = sorted(list(set(lyrics)))
char_to_int = dict((c, i) for i, c in enumerate(chars))

# 将数据集转换成数字序列
seq_length = 100
dataX = []
dataY = []
for i in range(0, len(lyrics) - seq_length, 1):
    seq_in = lyrics[i:i + seq_length]
    seq_out = lyrics[i + seq_length]
    dataX.append([char_to_int[char] for char in seq_in])
    dataY.append(char_to_int[seq_out])
n_patterns = len(dataX)

# 将数据转换成模型可以接受的格式
X = np.reshape(dataX, (n_patterns, seq_length, 1))
X = X / float(len(chars))
y = np_utils.to_categorical(dataY)

# 定义模型结构和超参数
embedding_dim = 256
lstm_units = 512
model = Sequential()
model.add(Embedding(len(chars), embedding_dim, input_length=seq_length))
model.add(LSTM(lstm_units, return_sequences=True))
model.add(LSTM(lstm_units))
model.add(Dense(len(chars), activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam')

Une fois le modèle défini et compilé, nous pouvons commencer à entraîner le modèle. Ici, nous allons entraîner le modèle en utilisant 50 époques et 128 tailles de lots.

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

Étape 4 : Générer des paroles

Après avoir entraîné le modèle, nous pouvons l'utiliser pour générer des paroles. Tout d'abord, nous devons définir une fonction qui acceptera une chaîne de texte de départ et la longueur souhaitée des paroles à générer, et utiliser le modèle entraîné pour générer de nouvelles paroles. Cela peut être fait en convertissant la chaîne de texte de départ en une séquence de nombres et en utilisant le modèle pour prédire le caractère suivant. Nous ajoutons ensuite les caractères prédits aux paroles générées et répétons ce processus jusqu'à ce que la longueur des paroles souhaitée soit atteinte.

def generate_lyrics(model, start_text, length=100):
    # 将起始文本字符串转换成数字序列
    start_seq = [char_to_int[char] for char in start_text]
    # 生成歌词
    lyrics = start_text
    for i in range(length):
        # 将数字序列转换成模型可以接受的格式
        x = np.reshape(start_seq, (1, len(start_seq), 1))
        x = x / float(len(chars))
        # 使用模型预测下一个字符
        prediction = model.predict(x, verbose=0)
        index = np.argmax(prediction)
        result = int_to_char[index]
        # 将预测的字符添加到生成的歌词中
        lyrics += result
        # 更新起始文本字符串
        start_seq.append(index)
        start_seq = start_seq[1:len(start_seq)]
    # 返回生成的歌词
    return lyrics

Nous pouvons utiliser cette fonction pour générer de nouvelles paroles. Par exemple, nous pouvons utiliser une chaîne de texte de départ « baby » pour générer de nouvelles paroles contenant 100 caractères.

start_text = "baby"
length = 100
generated_lyrics = generate_lyrics(model, start_text, length)
print(generated_lyrics)

Sortie :

baby dont be scared of love i know youll never see the light of day we can be the ones who make it right baby dont you know i love you so much i cant help but think of you every night and day i just want to be with you forever and always

Ces nouvelles paroles ressemblent beaucoup aux paroles de l'ensemble de données d'origine, mais elles sont générées sur la base des prédictions du modèle, elles sont donc quelque peu créatives et uniques.

Pour résumer, nous pouvons utiliser l'AIGC pour aider à la création lyrique et fournir inspiration et créativité. Si vous avez des besoins spécifiques, vous pouvez également utiliser le service AIGC de la plateforme NetEase Fuxi pour le générer en un clic, ce qui est plus pratique et plus rapide.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!