파이톤과 Flask에서 AI 챗봇을 만드는 방법

아마도 당신은 이 단어를 듣고 알고 싶을 것이다. 이 채팅 로봇은 무엇입니까? 그것은 무엇에 쓰입니까? 나는 정말 하나가 필요합니까? 나는 어떻게 해야만 하나를 만들 수 있습니까?만약에 당신이 자신의 간단한 채팅 로봇을 구축하고 싶다면 본고는 당신을 위해 채팅 로봇을 만드는 모든 절차를 완성할 것입니다.그냥 뛰어들래요.
예비 작업:

파이톤 프로그래밍 지식

플라스크 프레임 지식

기계학습 및 알고리즘지식

카탈로그

What is a chatbot?

Where is a chatbot used?

Do you need a chatbot?

Categories of chatbots

Terms Used

Start Programming

What is a Chatbot?
채팅 로봇은 인공 채팅 에이전트라고도 불리며 기계 학습 알고리즘에 의해 구동되는 소프트웨어 프로그램으로 사용자가 입력한 텍스트나 음성을 입력으로 하여 사용자와의 클래스 대화를 모의하는 데 목적을 둔다.

Where is it used?
채팅 로봇은 광범위한 용도를 가지고 있기 때문에 우리는 그 용도를 상세하게 설명할 수 없다.그러나 기본적으로 당신은 다음과 같은 측면에서 그것들을 찾을 수 있다. 서비스 데스크, 거래 처리, 고객 지원, 예약 서비스, 그리고 24-7시간 동안 고객과 실시간 채팅을 제공할 수 있다.

Do I need one?
응, 이것은 개성화된 의견인데, 그 중 하나는 반드시 원가 효율 분석을 하고, 그것이 가치 있는 프로젝트인지 아닌지를 결정해야 한다.
현재의 기술 플랫폼에서 대다수 회사들은 그들이 필요로 하는 일상적인 서비스를 제공하기 위해 채팅 로봇을 사용하는 것으로 서서히 넘어가고 있다.모두가 사용하는 좋은 예는 구글 어시스턴트, 애플 시리, 삼성 빅스비와 아마존 알렉사다.
본고에서 우리는 TensorFlow를 사용하여 Python에서 모델을 만드는 방법을 배워서 모델과 자연 언어 처리(nltk)를 훈련시켜 기계가 사용자의 조회를 이해하도록 돕는다.
There are two broad categories of chatbots:

규칙에 기초한 방법 - 여기서 로봇은 일부 설정된 규칙에 따라 훈련한다.바로 이런 규칙에 따라 로봇은 간단한 조회를 처리할 수 있지만 복잡한 조회를 처리할 수 없다.

자동 학습 방법 - 로봇은 기계 학습 알고리즘과 기술을 사용하여 채팅을 한다.그것은 두 종류로 한층 더 세분화되었다.

검색 기반 모델 - 이 모델에서 로봇은 사용자의 입력에 따라 목록에서 가장 좋은 응답을 검색한다.

생성 모형 - 이 모형은 주어진 목록에서 검색하지 않고 답을 제시합니다.이것들은 스마트 로봇이다.

이 채팅 로봇에서 우리는 규칙에 기초한 방법을 사용할 것이다.

Terms to encounter
자연언어처리(nltk)-이것은 언어학, 컴퓨터과학, 정보공학과 인공지능의 한 분야로 컴퓨터와 인류(자연)언어 간의 상호작용과 관련된다.
레몬화 - 이것은 단어의 서로 다른 굴절 형식을 한데 조합하는 과정이기 때문에 그것들을 하나의 항목으로 분석할 수 있다. 이것은 어간의 변체이다.예를 들어'발'과'발'은 모두'발'로 여겨진다.
어간-이것은 굴절사를 어간, 어기 또는 어근 형식으로 환원시키는 과정이다.예를 들어 만약에 우리가 단어'eat','eating','eats'뒤에 어미를 붙이면 결과는 하나의 단어'eat'이다.
태그화 - 태그는 단일 단어이며, 태그화는 텍스트 또는 텍스트 세트를 단일 단어나 문장으로 분할하는 것을 의미합니다.
단어 패키지 - 이것은 텍스트 모델링의 NLP 기술로 기계 학습 알고리즘의 텍스트 데이터를 나타내는 데 쓰인다.이것은 텍스트에서 특징을 추출하는 방법으로 기계 학습 알고리즘에 쓰인다.

Let's start programming now

Directory structure

|--  Static
|    |--  style.css
|--  Templates
|    |--  index.html
|--  app.py
|--  train.py
|--  intents.json
|--  words.pkl
|--  classes.pkl
|--  chatbot_model.h5

우선, 우리는 우리가 필요한 모든 라이브러리와 모듈을 가지고 있는지 확보해야 한다.다음 명령을 사용하여 tensorflow, nltk,flask를 설치합니다.

pip install tensorflow
pip install tensorflow-gpu
pip install nltk
pip install Flask

우리의 의도.json 파일은 이렇습니다. Here 죄송합니다. 이것은 매우 긴 파일입니다. 저는 그것을 여기에 삽입할 수 없습니다.
이제 우리는 준비가 다 되었으니 기차를 만드는 것부터 시작합시다.py 파일.우리는 우리가 사용할 모든 가방과 라이브러리를 가져올 필요가 있습니다.

# libraries
import random
from tensorflow.keras.optimizers import SGD
from keras.layers import Dense, Dropout
from keras.models import load_model
from keras.models import Sequential
import numpy as np
import pickle
import json
import nltk
from nltk.stem import WordNetLemmatizer

punkt,omw-1.4,wordnet 패키지를 다운로드하세요.Punkt는 텍스트를 일련의 문장으로 나누는 사전 훈련된 영어 표기기 모델이다.

nltk.download('omw-1.4')
nltk.download("punkt")
nltk.download("wordnet")

우리는 현재 일부 파일을 초기화하고 훈련 데이터를 불러올 필요가 있다."""?""은(는) 무시됩니다."그리고 "!".모델에 다른 기호나 문자를 무시하려면 ignore words 배열에 추가할 수 있습니다.

# init file
words = []
classes = []
documents = []
ignore_words = ["?", "!"]
data_file = open("intents.json").read()
intents = json.loads(data_file)

그리고 저희가 저희의 말을 표시해 드릴게요.

for intent in intents["intents"]:
    for pattern in intent["patterns"]:

        # take each word and tokenize it
        w = nltk.word_tokenize(pattern)
        words.extend(w)
        # adding documents
        documents.append((w, intent["tag"]))

        # adding classes to our class list
        if intent["tag"] not in classes:
            classes.append(intent["tag"])

다음에 우리는 단어를 문법화하여pickle 파일에 넣을 것이다

words = [lemmatizer.lemmatize(w.lower()) for w in words if w not in ignore_words]
words = sorted(list(set(words)))

classes = sorted(list(set(classes)))

print(len(documents), "documents")

print(len(classes), "classes", classes)

print(len(words), "unique lemmatized words", words)


pickle.dump(words, open("words.pkl", "wb"))
pickle.dump(classes, open("classes.pkl", "wb"))

지금 우리는 훈련 데이터가 생겨서 모형 훈련을 초기화했다

# initializing training data
training = []
output_empty = [0] * len(classes)
for doc in documents:
    # initializing bag of words
    bag = []
    # list of tokenized words for the pattern
    pattern_words = doc[0]
    # lemmatize each word - create base word, in attempt to represent related words
    pattern_words = [lemmatizer.lemmatize(word.lower()) for word in pattern_words]
    # create our bag of words array with 1, if word match found in current pattern
    for w in words:
        bag.append(1) if w in pattern_words else bag.append(0)

    # output is a '0' for each tag and '1' for current tag (for each pattern)
    output_row = list(output_empty)
    output_row[classes.index(doc[1])] = 1

    training.append([bag, output_row])
# shuffle our features and turn into np.array
random.shuffle(training)
training = np.array(training)
# create train and test lists. X - patterns, Y - intents
train_x = list(training[:, 0])
train_y = list(training[:, 1])
print("Training data created")

우리는 3층 출력 모델을 만들 것이다.1층에는 128개의 신경원, 2층에는 64개의 신경원이 있는데 3층에 포함된 신경원 수량은softmax를 사용하여 출력 의도를 예측하는 의도 수량과 같다.
우리는 ReLu를 사용하여 기능을 활성화할 것입니다. 왜냐하면 그것은 더욱 쉽게 훈련하고 좋은 성능을 얻을 수 있기 때문입니다.

model = Sequential()
model.add(Dense(128, input_shape=(len(train_x[0]),), activation="relu"))
model.add(Dropout(0.5))
model.add(Dense(64, activation="relu"))
model.add(Dropout(0.5))
model.add(Dense(len(train_y[0]), activation="softmax"))
model.summary()

그리고 우리는 모형을 컴파일한다.이 모델은 Nesterov 가속 사다리의 무작위 사다리 하강법을 적용해 좋은 결과를 얻었다.나는 랜덤 계단의 하락에 대해 상세하게 토론하지 않을 것이다. 왜냐하면 그 자체가 매우 복잡한 화제이기 때문이다.

sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(loss="categorical_crossentropy", optimizer=sgd, metrics=["accuracy"])

선택 사항: 최적의 훈련 주기수를 선택하여 의합이 부족하거나 과도하게 의합되지 않도록 하기 위해 정확도나 손실 모니터링에 따라 Keras에 대한 리셋을 미리 중지하십시오.피해를 모니터링하고 있으면 손실치 증가가 관찰되면 교육이 중단된다.또는 정밀도를 감시하고 있으면 정밀도가 떨어지는 것을 관측할 때 교육이 멈춘다.

from Keras import callbacks 
earlystopping = callbacks.EarlyStopping(monitor ="loss", mode ="min", patience = 5, restore_best_weights = True)
callbacks =[earlystopping]

이제 Flask REST API에서 쉽게 액세스할 수 있도록 모델을 훈련하고 저장할 수 있습니다.

hist = model.fit(np.array(train_x), np.array(train_y), epochs=200, batch_size=5, verbose=1)
model.save("chatbot_model.h5", hist)
print("model created")

너의 기차.py 파일은 이제 다음과 같습니다.

# libraries
import random
import numpy as np
import pickle
import json
from flask import Flask, render_template, request
from flask_ngrok import run_with_ngrok
import nltk
from keras.models import load_model
from nltk.stem import WordNetLemmatizer
lemmatizer = WordNetLemmatizer()


# chat initialization
model = load_model("chatbot_model.h5")
intents = json.loads(open("intents.json").read())
words = pickle.load(open("words.pkl", "rb"))
classes = pickle.load(open("classes.pkl", "rb"))

app = Flask(__name__)
#run_with_ngrok(app) -Use this option if you have ngrok and you want to expose your chatbot to the real world

@app.route("/")
def home():
    return render_template("index.html")

@app.route("/get", methods=["POST"])
def chatbot_response():
    msg = request.form["msg"]
    if msg.startswith('my name is'):
        name = msg[11:]
        ints = predict_class(msg, model)
        res1 = getResponse(ints, intents)
        res =res1.replace("{n}",name)
    elif msg.startswith('hi my name is'):
        name = msg[14:]
        ints = predict_class(msg, model)
        res1 = getResponse(ints, intents)
        res =res1.replace("{n}",name)
    else:
        ints = predict_class(msg, model)
        res = getResponse(ints, intents)
    return res

def clean_up_sentence(sentence):
    sentence_words = nltk.word_tokenize(sentence)
    sentence_words = [lemmatizer.lemmatize(word.lower()) for word in sentence_words]
    return sentence_words


# return bag of words array: 0 or 1 for each word in the bag that exists in the sentence
def bow(sentence, words, show_details=True):
    # tokenize the pattern
    sentence_words = clean_up_sentence(sentence)
    # bag of words - matrix of N words, vocabulary matrix
    bag = [0] * len(words)
    for s in sentence_words:
        for i, w in enumerate(words):
            if w == s:
                # assign 1 if current word is in the vocabulary position
                bag[i] = 1
                if show_details:
                    print("found in bag: %s" % w)
    return np.array(bag)

def predict_class(sentence, model):
    # filter out predictions below a threshold
    p = bow(sentence, words, show_details=False)
    res = model.predict(np.array([p]))[0]
    ERROR_THRESHOLD = 0.25
    results = [[i, r] for i, r in enumerate(res) if r > ERROR_THRESHOLD]
    # sort by strength of probability
    results.sort(key=lambda x: x[1], reverse=True)
    return_list = []
    for r in results:
        return_list.append({"intent": classes[r[0]], "probability": str(r[1])})
    return return_list


def getResponse(ints, intents_json):
    tag = ints[0]["intent"]
    list_of_intents = intents_json["intents"]
    for i in list_of_intents:
        if i["tag"] == tag:
            result = random.choice(i["responses"])
            break
    return result