Análisis y resumen del diseño del robot de chat basado en el paquete de análisis de herramientas OneAPI TensorFlow

Introducción básica:

Los chatbots basados ​​en TensorFlow utilizan principalmente métodos de aprendizaje profundo automático, y el modelo más utilizado es el modelo seq2seq+Attention. Este modelo puede realizar la traducción automática o la generación de la oración de origen a la oración de destino. En el robot de chat, la pregunta del usuario se puede usar como oración de origen, la respuesta generada por el robot se puede usar como oración de destino y se puede construir un robot de diálogo inteligente a través de la capacitación y el aprendizaje del modelo.

En primer lugar, usar el marco de segmentación de palabras chinas jieba para segmentar textos de caracteres chinos es segmentar oraciones en palabras manejables. Esto puede ayudar al modelo a comprender mejor la semántica de las oraciones y, al mismo tiempo, reducir la dimensionalidad de los datos de entrada. Después de la tokenización, cada palabra se codifica con un número de identificación para que el modelo pueda procesarla.

Luego, a través del entrenamiento y aprendizaje de una gran cantidad de datos, el modelo puede aprender gradualmente las leyes y conceptos del lenguaje. El modelo se puede entrenar utilizando un corpus de pares de preguntas y respuestas para que el modelo aprenda a asociar preguntas con las respuestas correspondientes. Durante el proceso de entrenamiento, el algoritmo de retropropagación y el optimizador se pueden usar para ajustar los parámetros del modelo de modo que el modelo pueda generar la respuesta correcta.

Una vez completada la capacitación, el chatbot está listo para conversaciones reales. Cuando un usuario ingresa una pregunta, el robot la identifica y la convierte en un formulario codificado con ID, que luego se introduce en el modelo. El modelo se propaga hacia adelante para calcular una distribución de probabilidad que represente posibles respuestas. Al seleccionar la respuesta con la probabilidad más alta, el bot puede generar una respuesta correspondiente y devolvérsela al usuario.

Entre ellos, para mejorar el efecto del modelo, es muy importante introducir el mecanismo Atención. El mecanismo Atención puede ayudar al modelo a prestar más atención a la información contextual relevante al generar cada palabra, mejorando así la comprensión semántica del modelo y la calidad de la respuesta.

Además, para enriquecer el corpus y mejorar la capacidad de generalización del modelo, es posible utilizar no solo pares de preguntas y respuestas como datos de entrenamiento, sino también incluir otros tipos de diálogos, como conversaciones informales, preguntas frecuentes, etc. etc. Esto puede hacer que el robot tenga cierta capacidad para responder a varios tipos de preguntas.

En resumen, el modelo de aprendizaje profundo se utiliza para entrenar y aprender a realizar coincidencias y respuestas automáticas del diálogo humano-computadora. A través del preprocesamiento de datos adecuado, la codificación de segmentación de palabras, la construcción y optimización de modelos y la introducción del mecanismo de Atención, los chatbots pueden equiparse con mejores capacidades de diálogo y capacidades de comprensión semántica.

Ideas de implementación:

1. Preprocesamiento de datos : segmente las preguntas y respuestas en el corpus y use la herramienta de segmentación de palabras chinas jieba para procesar el texto de caracteres chinos. Cada segmentación de palabra tras palabra se asignará a un número de identificación único para que el modelo pueda manejarlo.

2. Construcción del modelo : use el marco TensorFlow para construir un modelo de robot de diálogo basado en el aprendizaje profundo de la máquina, usando el modelo seq2seq+Attention. El modelo Seq2seq consta de un codificador (Codificador) y un decodificador (Decodificador). El codificador convierte la secuencia de preguntas de entrada en una representación vectorial de longitud fija, y el decodificador utiliza este vector para generar una respuesta.

3. Preparación de datos de entrenamiento : use una gran cantidad de datos de pares de preguntas y respuestas como conjunto de entrenamiento, en el que la pregunta se usa como secuencia de entrada y la respuesta se usa como secuencia de destino. Los datos de capacitación se pueden obtener rastreando comunidades de preguntas y respuestas en Internet o utilizando conjuntos de datos abiertos existentes.

4. Entrenamiento del modelo : ingrese los datos de entrenamiento preparados en el modelo para el entrenamiento y use el algoritmo de retropropagación y el optimizador para ajustar los parámetros del modelo para que el modelo pueda generar respuestas correctas. Se puede configurar una función de pérdida adecuada, como la función de pérdida de entropía cruzada, para evaluar la brecha entre la salida del modelo y la respuesta real, y optimizar el modelo.

5. Coincidencia y generación de respuestas : cuando el usuario ingresa una pregunta, la segmentación de palabras se realiza en la oración de entrada y la secuencia posterior a la segmentación de palabras se ingresa en el modelo entrenado. El modelo convierte la secuencia de preguntas en una representación vectorial a través del codificador, y luego el decodificador usa este vector para generar una respuesta. En el proceso del decodificador, el mecanismo de Atención puede ayudar al modelo a enfocarse en información contextual relevante y mejorar la calidad y precisión de la respuesta.

6. Evaluación y mejora del modelo : evalúe el modelo a través de la evaluación manual y la evaluación del conjunto de pruebas, y mejore y optimice el modelo en función de los resultados de la evaluación. De acuerdo con las necesidades de los escenarios de aplicación reales, los hiperparámetros y las funciones de pérdida del modelo se pueden ajustar para mejorar la capacidad de respuesta y el nivel de inteligencia del robot.

introducción detallada

1. El historial de desarrollo de los chatbots:

• Primera generación: chatbots basados ​​en reglas que generan respuestas escribiendo reglas predefinidas y coincidencia de patrones. Estas reglas están escritas manualmente, no pueden cubrir todas las situaciones de diálogo posibles y son difíciles de manejar en un lenguaje natural complejo.

• La segunda generación: chatbots con métodos estadísticos, que introducen tecnología de aprendizaje automático, modelan y entrenan a través de métodos estadísticos, como el uso de modelos n-gram para el modelado de lenguaje y el uso de estimación de máxima verosimilitud para generar respuestas. Aunque puede mejorar la fluidez del diálogo hasta cierto punto, carece de la capacidad de comprender la semántica y el contexto, y las respuestas generadas pueden ser inexactas.

• La tercera generación: Chatbots basados ​​en aprendizaje profundo, usando modelos de redes neuronales para modelado y entrenamiento. Entre ellos, el modelo seq2seq (Sequence-to-Sequence) es una estructura de modelo común, que consta de un codificador (Codificador) y un decodificador (Decodificador), mediante el mapeo de la secuencia de entrada en una representación vectorial de longitud fija, y luego el El vector sirve como estado inicial del decodificador para generar la secuencia de salida. Para centrarse en la información relevante en la secuencia de entrada y mejorar la calidad de la respuesta, se introduce el mecanismo Atención.

2. Interfaz embedding_attention_seq2seq:

• embedding_attention_seq2seq es una interfaz en TensorFlow para construir un modelo seq2seq+Attention.
• Los parámetros de la interfaz incluyen principalmente entradas de codificador, entradas de decodificador y estados de atención.
• encoder_inputs representa la secuencia de entrada del codificador, decoder_inputs representa la secuencia de entrada del decodificador, ytention_states representa la representación vectorial utilizada para calcular el peso de Atención.
• Otros parámetros comúnmente utilizados incluyen num_encoder_symbols, num_decoder_symbols, embedding_size, num_heads, etc., que se utilizan para especificar el tamaño del vocabulario, la dimensión del vector de palabra, el número de cabezas de atención, etc.

3. Entrena el modelo:

(1) Segmentación de palabras chinas : use la biblioteca jieba para realizar el procesamiento de segmentación de palabras en textos chinos y dividir oraciones en secuencias de palabras.

(2) Obtención de la función del conjunto de entrenamiento : según el escenario de la aplicación, los datos de respuesta a la pregunta se pueden rastrear desde Internet o se puede usar un conjunto de datos abiertos existente como conjunto de entrenamiento. Convierta los datos de respuesta de preguntas al formato requerido por el modelo y divídalos en conjuntos de entrenamiento y validación.

(3) Obtenga la función de identificación de oración : use el vocabulario para convertir la oración después de la segmentación de palabra en una secuencia de identificación de oración, lo cual es conveniente para que el modelo procese.

(4) Función de predicción : defina la etapa de inferencia del modelo, realice la generación de secuencias y genere respuestas a través del codificador y decodificador.

(5) Parámetros de optimización : Seleccione una función de pérdida apropiada (como la función de pérdida de entropía cruzada), optimizador (como el optimizador de Adam) e hiperparámetros para entrenar y optimizar el modelo.

4. Programación en Python para realizar un robot de chat completo:

• Según los pasos descritos anteriormente, se puede construir un sistema de chatbot utilizando el lenguaje de programación Python.
• Al presentar la biblioteca jieba para la segmentación de palabras chinas, cree un modelo seq2seq+Attention y use la interfaz proporcionada por TensorFlow para el entrenamiento y la predicción del modelo.
• Durante el proceso de codificación, el modelo puede optimizarse y mejorarse adecuadamente en función de las necesidades reales, como agregar más datos de entrenamiento, ajustar la estructura del modelo y los hiperparámetros, etc.
• Finalmente, se lleva a cabo una depuración del sistema para garantizar que el robot pueda dar respuestas precisas y razonables a las preguntas planteadas por los usuarios, y tenga un cierto nivel de inteligencia.

para agregar:

Para ampliar y enriquecer la funcionalidad de los chatbots, se pueden considerar algunos de los siguientes aspectos:

• Reconocimiento de entidades : introduzca la tecnología de reconocimiento de entidades para extraer información clave de las preguntas para responder a las preguntas de los usuarios con mayor precisión.
• Reconocimiento de intención : Clasifique las preguntas del usuario por intención, para comprender mejor las necesidades del usuario y dar las respuestas correspondientes.
• Gestión del diálogo : Al introducir la tecnología de gestión del diálogo, los chatbots pueden realizar múltiples rondas de diálogo, recordar información contextual y comunicarse de manera coherente.
• Procesamiento multimodal : la combinación de múltiples métodos de entrada, como texto, imágenes y voz, permite que los chatbots manejen diversas entradas de usuarios.
• Adaptación del dominio : según el escenario de aplicación específico, el robot de chat se adapta al dominio para brindar respuestas más profesionales y específicas.
• Mecanismo de comentarios de los usuarios : agregue un mecanismo de comentarios de los usuarios para recopilar continuamente comentarios y sugerencias de los usuarios con el fin de optimizar y mejorar el rendimiento de los chatbots.

Construcción del entorno y tecnologías clave

Construcción del entorno

Use el intérprete de python de python3.6, tensorflow versión = 1.14, embedding_attention_seq2seq de tensorflow, use la red neuronal LSTM, use el optimizador AdamOptimizer, la segmentación de palabras chinas jieba, etc. El proceso de instalación y construcción de cada elemento es el siguiente:

1. Instale Anaconda (administrador de paquetes y administrador de entornos):
   Anaconda viene con una gran colección de paquetes de ciencia de datos de uso común, viene con conda, Python y más de 150 paquetes científicos y sus dependencias. Para que pueda comenzar a procesar datos de inmediato. En el análisis de datos, se utilizan muchos paquetes de terceros, y conda (administrador de paquetes) puede ayudarlo a instalar y administrar estos paquetes en su computadora, incluida la instalación, desinstalación y actualización de paquetes.

(1) Pasos e instrucciones de instalación y configuración de Anaconda:

• a. Ingrese al sitio web oficial y haga clic en Descargar;
• b. Elija la versión apropiada de su computadora para descargar (elija la versión de 64 bits de 2020.11);
• C. Busque el instalador según su propia ruta de descarga y haga clic en el instalador para instalar;
• D. Siga las indicaciones para instalar de acuerdo con las opciones predeterminadas y finalmente haga clic en Finalizar para completar la instalación;
• e. Abra "Propiedades del sistema-Avanzado-Variables de entorno-Usuario Variables de usuario-Seleccione ruta-Editar para configurar el entorno y agregue la ruta de su propia instalación después del valor de la variable de la siguiente manera:
  
• F. Haga clic en Aceptar para completar la configuración del entorno.
• G. Haga clic en Inicio para abrir el indicador de Anaconda (Anaconda3) e ingrese un terminal como Anaconda3 para cambiar la fuente de imagen doméstica e ingrese el siguiente comando en la línea de comando:

conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/conda-forge
conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/msys2/

• h. Mostrar la dirección del canal al configurar la búsqueda

conda config --set show_channel_urls yes

Anaconda completa la instalación.

1. Use Anaconda3 para instalar el intérprete python3.6:
(1) Ingrese a la interfaz cmd del sistema Windows: luego ingrese: conda --version para verificar la versión de anaconda, el resultado se muestra en la figura (3)


Instalar python y cree un entorno de tensorflow
(4) conda search --full --name pythonVerifique la versión de python compatible con anaconda

(5) Instale el intérprete de Python y cree el entorno tensorflow0 conda create --name tensorflow0 python=3.6;
(6) El comando para ingresar al entorno tensorflow0 es: active tensorflow0

2. Instale tensorflow1.14 en el entorno tensorflow0,
(1) El comando es pip install --upgrade --ignore-installed tensorflow, la instalación es exitosa tensorflow=1.14 versión,
(2) Verifique si la instalación de tensorflow es exitosa o no, ingrese el siguiente código:

import tensorflow as tf
hello = tf.constant(‘hello,tf’)
sess = tf.Session()
print(sess.run(hello))

3. Instale y configure el entorno tensorflow0 en el IDE Pycham que ejecuta el código
(1) Descargue e instale Pycham: ingrese al sitio web oficial de Pycham para descargar el paquete de instalación de la versión comunitaria de Pycham en el local, haga clic en la opción predeterminada para instalar.
(2) Añadir entornotensorflow0到Pycham

tecnología clave

Anaconda3 presta atención a la configuración de la ruta correcta en la configuración de la variable de entorno después de la instalación. Al elegir la versión de Python, debe prestar atención a la elección de la versión de Python 3.6. La razón es que la última versión no puede instalar la versión de tensorflow 1.14. La versión correcta la elección de la versión de tensorflow es la clave para el funcionamiento exitoso del programa. El factor clave de no, dado que el aprendizaje automático basado en tensorflow se refiere principalmente a la compañía de Google, la mayoría de sus marcos e interfaces de algoritmos no son compatibles con tensorflow2, he encontrado muchas dificultades en la selección y descarga de tensorflow, el entorno debe construirse basado en python3.6 y Tensorflow1.14 versión, otra biblioteca de segmentación de palabras chinas jieba requerida, seq2seq y la biblioteca numpy son operaciones relativamente simples Específicamente, ingrese el siguiente comando en Terminal para instalarlo correctamente.
El comando para instalar la biblioteca numpy: pip install numpy
el comando para instalar la biblioteca jieba: pip install jieba
el comando para instalar la biblioteca seq2seq:pip install seq2seq

Código

1. Toma la palabra número:

# coding:utf-8
import sys
import jieba
from numpy import unicode


class WordToken(object):
    def __init__(self):
        # 最小起始id号, 保留的用于表示特殊标记
        self.START_ID = 4
        self.word2id_dict = {
    
    }
        self.id2word_dict = {
    
    }


    def load_file_list(self, file_list, min_freq):
        """
        加载样本文件列表，全部切词后统计词频，按词频由高到低排序后顺次编号
        并存到self.word2id_dict和self.id2word_dict中
        """
        words_count = {
    
    }
        for file in file_list:
            with open(file, 'r',encoding='utf-8') as file_object:
                for line in file_object.readlines():
                    line = line.strip()
                    seg_list = jieba.cut(line)
                    for str in seg_list:
                        if str in words_count:
                            words_count[str] = words_count[str] + 1
                        else:
                            words_count[str] = 1

        sorted_list = [[v[1], v[0]] for v in words_count.items()]
        sorted_list.sort(reverse=True)
        for index, item in enumerate(sorted_list):
            word = item[1]
            if item[0] < min_freq:
                break
            self.word2id_dict[word] = self.START_ID + index
            self.id2word_dict[self.START_ID + index] = word
        return index

    def word2id(self, word):
        if not isinstance(word, unicode):
            print ("Exception: error word not unicode")
            sys.exit(1)
        if word in self.word2id_dict:
            return self.word2id_dict[word]
        else:
            return None

    def id2word(self, id):
        id = int(id)
        if id in self.id2word_dict:
            return self.id2word_dict[id]
        else:
            return None

2. Formación:

# coding:utf-8
import sys
import jieba
from numpy import unicode


class WordToken(object):
    def __init__(self):
        # 最小起始id号, 保留的用于表示特殊标记
        self.START_ID = 4
        self.word2id_dict = {
    
    }
        self.id2word_dict = {
    
    }


    def load_file_list(self, file_list, min_freq):
        """
        加载样本文件列表，全部切词后统计词频，按词频由高到低排序后顺次编号
        并存到self.word2id_dict和self.id2word_dict中
        """
        words_count = {
    
    }
        for file in file_list:
            with open(file, 'r',encoding='utf-8') as file_object:
                for line in file_object.readlines():
                    line = line.strip()
                    seg_list = jieba.cut(line)
                    for str in seg_list:
                        if str in words_count:
                            words_count[str] = words_count[str] + 1
                        else:
                            words_count[str] = 1

        sorted_list = [[v[1], v[0]] for v in words_count.items()]
        sorted_list.sort(reverse=True)
        for index, item in enumerate(sorted_list):
            word = item[1]
            if item[0] < min_freq:
                break
            self.word2id_dict[word] = self.START_ID + index
            self.id2word_dict[self.START_ID + index] = word
        return index

    def word2id(self, word):
        if not isinstance(word, unicode):
            print ("Exception: error word not unicode")
            sys.exit(1)
        if word in self.word2id_dict:
            return self.word2id_dict[word]
        else:
            return None

    def id2word(self, id):
        id = int(id)
        if id in self.id2word_dict:
            return self.id2word_dict[id]
        else:
            return None

3. Prueba:

# coding:utf-8
import sys
import numpy as np
import tensorflow as tf
from tensorflow.contrib.legacy_seq2seq.python.ops import seq2seq
import word_token
import jieba
import random

# 输入序列长度
input_seq_len = 5
# 输出序列长度
output_seq_len = 5
# 空值填充0
PAD_ID = 0
# 输出序列起始标记
GO_ID = 1
# 结尾标记
EOS_ID = 2
# LSTM神经元size
size = 8
# 初始学习率
init_learning_rate = 1
# 在样本中出现频率超过这个值才会进入词表
min_freq = 10

wordToken = word_token.WordToken()

# 放在全局的位置，为了动态算出num_encoder_symbols和num_decoder_symbols
max_token_id = wordToken.load_file_list(['./samples/question', './samples/answer'], min_freq)
num_encoder_symbols = max_token_id + 5
num_decoder_symbols = max_token_id + 5


def get_id_list_from(sentence):
    sentence_id_list = []
    seg_list = jieba.cut(sentence)
    for str in seg_list:
        id = wordToken.word2id(str)
        if id:
            sentence_id_list.append(wordToken.word2id(str))
    return sentence_id_list


def get_train_set():
    global num_encoder_symbols, num_decoder_symbols
    train_set = []
    with open('samples/question', 'r', encoding='utf-8') as question_file:
        with open('samples/answer', 'r', encoding='utf-8') as answer_file:
            while True:
                question = question_file.readline()
                answer = answer_file.readline()
                if question and answer:
                    question = question.strip()
                    answer = answer.strip()

                    question_id_list = get_id_list_from(question)
                    answer_id_list = get_id_list_from(answer)
                    if len(question_id_list) > 0 and len(answer_id_list) > 0:
                        answer_id_list.append(EOS_ID)
                        train_set.append([question_id_list, answer_id_list])
                else:
                    break
    return train_set


def get_samples(train_set, batch_num):

    raw_encoder_input = []
    raw_decoder_input = []
    if batch_num >= len(train_set):
        batch_train_set = train_set
    else:
        random_start = random.randint(0, len(train_set)-batch_num)
        batch_train_set = train_set[random_start:random_start+batch_num]
    for sample in batch_train_set:
        raw_encoder_input.append([PAD_ID] * (input_seq_len - len(sample[0])) + sample[0])
        raw_decoder_input.append([GO_ID] + sample[1] + [PAD_ID] * (output_seq_len - len(sample[1]) - 1))

    encoder_inputs = []
    decoder_inputs = []
    target_weights = []

    for length_idx in range(input_seq_len):
        encoder_inputs.append(np.array([encoder_input[length_idx] for encoder_input in raw_encoder_input], dtype=np.int32))
    for length_idx in range(output_seq_len):
        decoder_inputs.append(np.array([decoder_input[length_idx] for decoder_input in raw_decoder_input], dtype=np.int32))
        target_weights.append(np.array([
            0.0 if length_idx == output_seq_len - 1 or decoder_input[length_idx] == PAD_ID else 1.0 for decoder_input in raw_decoder_input
        ], dtype=np.float32))
    return encoder_inputs, decoder_inputs, target_weights


def seq_to_encoder(input_seq):
    """从输入空格分隔的数字id串，转成预测用的encoder、decoder、target_weight等
    """
    input_seq_array = [int(v) for v in input_seq.split()]
    encoder_input = [PAD_ID] * (input_seq_len - len(input_seq_array)) + input_seq_array
    decoder_input = [GO_ID] + [PAD_ID] * (output_seq_len - 1)
    encoder_inputs = [np.array([v], dtype=np.int32) for v in encoder_input]
    decoder_inputs = [np.array([v], dtype=np.int32) for v in decoder_input]
    target_weights = [np.array([1.0], dtype=np.float32)] * output_seq_len
    return encoder_inputs, decoder_inputs, target_weights


def get_model(feed_previous=False):
    """构造模型
    """

    learning_rate = tf.Variable(float(init_learning_rate), trainable=False, dtype=tf.float32)
    learning_rate_decay_op = learning_rate.assign(learning_rate * 0.9)

    encoder_inputs = []
    decoder_inputs = []
    target_weights = []
    for i in range(input_seq_len):
        encoder_inputs.append(tf.placeholder(tf.int32, shape=[None], name="encoder{0}".format(i)))
    for i in range(output_seq_len + 1):
        decoder_inputs.append(tf.placeholder(tf.int32, shape=[None], name="decoder{0}".format(i)))
    for i in range(output_seq_len):
        target_weights.append(tf.placeholder(tf.float32, shape=[None], name="weight{0}".format(i)))

    # decoder_inputs左移一个时序作为targets
    targets = [decoder_inputs[i + 1] for i in range(output_seq_len)]

    cell = tf.contrib.rnn.BasicLSTMCell(size)

    # 这里输出的状态我们不需要
    outputs, _ = seq2seq.embedding_attention_seq2seq(
                        encoder_inputs,
                        decoder_inputs[:output_seq_len],
                        cell,
                        num_encoder_symbols=num_encoder_symbols,
                        num_decoder_symbols=num_decoder_symbols,
                        embedding_size=size,
                        output_projection=None,
                        feed_previous=feed_previous,
                        dtype=tf.float32)

    # 计算加权交叉熵损失
    loss = seq2seq.sequence_loss(outputs, targets, target_weights)
    # 梯度下降优化器
    opt = tf.train.GradientDescentOptimizer(learning_rate)
    # 优化目标：让loss最小化
    update = opt.apply_gradients(opt.compute_gradients(loss))
    # 模型持久化
    saver = tf.train.Saver(tf.global_variables())

    return encoder_inputs, decoder_inputs, target_weights, outputs, loss, update, saver, learning_rate_decay_op, learning_rate


def train():
    """
    训练过程
    """
    train_set = get_train_set()
    with tf.Session() as sess:

        encoder_inputs, decoder_inputs, target_weights, outputs, loss, update, saver, learning_rate_decay_op, learning_rate = get_model()

        # 全部变量初始化
        sess.run(tf.global_variables_initializer())

        # 训练很多次迭代，每隔10次打印一次loss，可以看情况直接ctrl+c停止
        previous_losses = []
        for step in range(50000):
            sample_encoder_inputs, sample_decoder_inputs, sample_target_weights = get_samples(train_set, 1000)
            input_feed = {
    
    }
            for l in range(input_seq_len):
                input_feed[encoder_inputs[l].name] = sample_encoder_inputs[l]
            for l in range(output_seq_len):
                input_feed[decoder_inputs[l].name] = sample_decoder_inputs[l]
                input_feed[target_weights[l].name] = sample_target_weights[l]
            input_feed[decoder_inputs[output_seq_len].name] = np.zeros([len(sample_decoder_inputs[0])], dtype=np.int32)
            [loss_ret, _] = sess.run([loss, update], input_feed)
            if step % 10 == 0:
                print ('step=', step, 'loss=', loss_ret, 'learning_rate=', learning_rate.eval())

                if len(previous_losses) > 5 and loss_ret > max(previous_losses[-5:]):
                    sess.run(learning_rate_decay_op)
                previous_losses.append(loss_ret)

                # 模型持久化
                saver.save(sess, './model/demo')


def predict():
    """
    预测过程
    """
    with tf.Session() as sess:
        encoder_inputs, decoder_inputs, target_weights, outputs, loss, update, saver, learning_rate_decay_op, learning_rate = get_model(feed_previous=True)
        saver.restore(sess, './model/demo')
        sys.stdout.write("> ")
        sys.stdout.flush()
        input_seq = sys.stdin.readline()
        while input_seq:
            input_seq = input_seq.strip()
            input_id_list = get_id_list_from(input_seq)
            if (len(input_id_list)):
                sample_encoder_inputs, sample_decoder_inputs, sample_target_weights = seq_to_encoder(' '.join([str(v) for v in input_id_list]))

                input_feed = {
    
    }
                for l in range(input_seq_len):
                    input_feed[encoder_inputs[l].name] = sample_encoder_inputs[l]
                for l in range(output_seq_len):
                    input_feed[decoder_inputs[l].name] = sample_decoder_inputs[l]
                    input_feed[target_weights[l].name] = sample_target_weights[l]
                input_feed[decoder_inputs[output_seq_len].name] = np.zeros([2], dtype=np.int32)

                # 预测输出
                outputs_seq = sess.run(outputs, input_feed)
                # 因为输出数据每一个是num_decoder_symbols维的，因此找到数值最大的那个就是预测的id，就是这里的argmax函数的功能
                outputs_seq = [int(np.argmax(logit[0], axis=0)) for logit in outputs_seq]
                # 如果是结尾符，那么后面的语句就不输出了
                if EOS_ID in outputs_seq:
                    outputs_seq = outputs_seq[:outputs_seq.index(EOS_ID)]
                outputs_seq = [wordToken.id2word(v) for v in outputs_seq]
                print (" ".join(outputs_seq))
            else:
                print ("你觉得呢")

            sys.stdout.write("> ")
            sys.stdout.flush()
            input_seq = sys.stdin.readline()


if __name__ == "__main__":
    #训练:
    #train()
    #测试对话:
    predict()

Resumen y experiencia

Basado en el marco principal de aprendizaje profundo de la máquina del paquete de análisis de herramientas TensorFlow de OneAPI, el robot de chat que utiliza el modelo seq2seq+Attention realiza la segmentación de palabras en oraciones de texto chino a través del marco de segmentación de palabras en chino jieba y luego numera los resultados de la segmentación de palabras. Luego, a través de una gran cantidad de entrenamiento y aprendizaje de datos, se genera un modelo para que pueda realizar la función básica de diálogo hombre-máquina.

Dicho chatbot puede reconocer automáticamente la oración de chat de entrada y hacer coincidir la respuesta correspondiente a la pregunta. Está entrenado en un gran corpus de vocabulario de texto para generar respuestas a las preguntas de entrada.

El uso de un chatbot de este tipo puede obtener algunas conclusiones y nuevas experiencias, como:

• Comprensión y generación del lenguaje: con el aprendizaje profundo automático, los modelos pueden comprender el lenguaje humano y generar las respuestas correspondientes. Esta técnica tiene amplias perspectivas de aplicación en el campo del procesamiento del lenguaje natural.
• Consciente del contexto: el modelo seq2seq+Attention puede recordar la información de contexto del diálogo, para mantener la coherencia en múltiples rondas de diálogo y dar respuestas más precisas.
• Procesamiento multimodal: al usar el paquete de análisis de herramientas OneAPI TensorFlow, combinado con otras tecnologías como el procesamiento de imágenes y el procesamiento de voz, es posible realizar entradas y salidas multimodales y brindar una experiencia de diálogo más rica.
• Modelo de pre-entrenamiento: A través de mucho entrenamiento y aprendizaje, los chatbots pueden tener un cierto nivel de inteligencia, ser capaces de responder varios tipos de preguntas y hacer ajustes adaptativos basados ​​en corpus en diferentes campos.
• Expansión de escenarios de aplicación: los chatbots se pueden usar ampliamente en servicio al cliente, asistentes inteligentes, sistemas de respuesta a preguntas y otros campos para brindar a los usuarios una experiencia conveniente de interacción persona-computadora.

En resumen, el robot de chat basado en el paquete de análisis de herramientas OneAPI TensorFlow utiliza tecnología de aprendizaje profundo y modelo seq2seq+Attention, y después de una gran cantidad de entrenamiento y aprendizaje de datos, realiza la función básica de diálogo hombre-máquina. Puede reconocer automáticamente la entrada del usuario y dar las respuestas correspondientes. Dichos robots han logrado resultados satisfactorios en la comprensión y generación de lenguaje, conocimiento del contexto, procesamiento multimodal y modelos pre-entrenados, brindando ricas posibilidades para varios escenarios de aplicación.