Conteúdo[Esconder][Mostrar]
As chamadas de voz estão sendo eliminadas em favor de texto e recursos visuais no setor de comunicação. De acordo com uma pesquisa do Facebook, mais da metade dos compradores preferem comprar de uma empresa com a qual podem falar. O bate-papo tornou-se o novo modo de comunicação socialmente aceitável.
Ele permite que as empresas se comuniquem com seus clientes a qualquer momento e de qualquer local. Os chatbots estão ganhando cada vez mais popularidade entre empresas e clientes devido à sua facilidade de uso e tempos de espera reduzidos.
Os chatbots, ou programas de conversação automatizados, fornecem aos clientes um método mais personalizado para acessar os serviços por meio de uma interface baseada em texto. Os mais novos chatbots com inteligência artificial podem reconhecer uma consulta (pergunta, comando, ordem etc.) feita por uma pessoa (ou outro bot, início) em um ambiente específico e responder adequadamente (resposta, ação, etc.).
Neste post, veremos o que são chatbots, seus benefícios, casos de uso e como criar o seu próprio deep learning chatbot em Python, entre outras coisas.
Vamos começar.
Então, o que são chatbots?
Um chatbot é frequentemente referido como uma das formas mais avançadas e promissoras de interação homem-máquina. Esses assistentes digitais melhoram a experiência do cliente simplificando as interações entre pessoas e serviços.
Simultaneamente, eles fornecem às empresas novas opções para otimizar o processo de contato com o cliente para obter eficiência, o que pode reduzir as despesas de suporte convencionais.
Em poucas palavras, é um software baseado em IA que se destina a se comunicar com humanos em seus idiomas naturais. Esses chatbots geralmente interagem por meio de técnicas de áudio ou escritas e podem imitar facilmente idiomas humanos para se conectar com humanos de maneira semelhante a humanos.
Os chatbots aprendem com suas interações com os usuários, tornando-se mais realistas e eficientes ao longo do tempo. Eles podem lidar com uma ampla gama de atividades de negócios, como autorizar gastos, interagir com consumidores on-line e gerar leads.
Criando seu próprio chatbot de aprendizado profundo com python
Existem muitos tipos distintos de chatbots no campo da aprendizado de máquina e IA. Alguns chatbots são assistentes virtuais, enquanto outros estão lá apenas para conversar, enquanto outros são agentes de atendimento ao cliente.
Você provavelmente já viu alguns dos empregados por empresas para responder a perguntas. Faremos um pequeno chatbot neste tutorial para responder a consultas solicitadas com frequência.
1. Instalando pacotes
Nosso primeiro passo é instalar os seguintes pacotes.
2. Dados de treinamento
Agora é hora de descobrir que tipo de informação precisaremos fornecer ao nosso chatbot. Não precisamos baixar grandes conjuntos de dados porque este é um chatbot simples.
Utilizaremos apenas as informações que nós mesmos criamos. Para acompanhar a lição com eficiência, você precisará gerar um arquivo .JSON com o mesmo formato que o mostrado abaixo. Meu arquivo se chama “intents.json”.
O arquivo JSON é usado para criar um conjunto de mensagens que o usuário provavelmente inserirá e mapeará para um conjunto de respostas relevantes. Cada dicionário do arquivo possui uma tag que identifica a qual grupo cada mensagem pertence.
Usaremos essas informações para treinar um rede neural para categorizar uma frase de palavras como uma das tags em nosso arquivo.
Podemos então pegar uma resposta desses grupos e fornecê-la ao usuário. O chatbot será melhor e mais complicado se você o oferecer com tags, respostas e padrões adicionais.
3. Carregamento de dados JSON
Começaremos carregando nossos dados .json e importando alguns módulos. Monte seu arquivo.json no mesmo diretório que seu Script Python. Nossos dados .json agora serão salvos na variável de dados.
4. Extração de dados
Agora é hora de extrair as informações que precisamos do nosso arquivo JSON. Todos os padrões, bem como a classe/tag a que pertencem, são obrigatórios.
Também precisaremos de uma lista de todos os termos exclusivos em nossos padrões (por motivos que explicaremos mais adiante), então vamos criar algumas listas em branco para acompanhar esses valores.
Agora vamos percorrer nossos dados JSON e recuperar as informações de que precisamos. Em vez de tê-los como strings, usaremos o tokenizer nltk.word para transformar cada padrão em uma lista de palavras.
Em seguida, em nossa lista docs_x, adicionaremos cada padrão, juntamente com sua tag associada, à lista docs_y.
5. Derivação de palavras
Encontrar a raiz de uma palavra é conhecido como stemming. Por exemplo, a raiz da palavra "isso" pode ser "isso", enquanto a raiz da palavra "acontece" pode ser "acontecer".
Usaremos essa técnica de stemming para reduzir o vocabulário do nosso modelo e tentar descobrir o que as frases implicam em geral. Esse código simplesmente gerará uma lista exclusiva de palavras derivadas que serão usadas na próxima fase de nossa preparação de dados.
6. Saco de Palavras
É hora de falar sobre um pacote de palavras agora que importamos nossos dados e geramos um vocabulário derivado. Redes neurais e algoritmos de aprendizado de máquina, como todos sabemos, exigem entrada numérica. Portanto, nossa lista de strings não será suficiente. Precisamos de um mecanismo para representar números em nossas frases, que é onde entra um saco de palavras.
Cada frase será representada por uma lista do tamanho do número de termos no vocabulário do nosso modelo. Cada palavra do nosso vocabulário será representada por um lugar na lista. Se a posição na lista for 1, a palavra aparecerá em nossa declaração; se for 0, a palavra não aparece em nossa frase.
Chamamos de saco de palavras porque não sabemos a sequência em que as palavras aparecem na frase; tudo o que sabemos é que eles existem no vocabulário do nosso modelo.
Além de estruturar nossa entrada, também devemos formatar nossa saída para que a rede neural a entenda. Criaremos listas de saída com o tamanho do número de rótulos/tags em nosso conjunto de dados, semelhante a um pacote de palavras. Cada lugar na lista representa um rótulo/etiqueta exclusivo, e um 1 em qualquer um desses locais indica qual rótulo/etiqueta está sendo representado.
Por fim, usaremos matrizes NumPy para armazenar nossos dados de treinamento e saída.
7. Desenvolvimento de modelo
Estamos prontos para começar a construir e treinar um modelo agora que pré-processamos todos os nossos dados. Utilizaremos uma rede neural feed-forward muito básica com duas camadas ocultas para nossos objetivos.
O objetivo da nossa rede será olhar para uma coleção de palavras e atribuí-las a uma classe (uma de nossas tags do arquivo JSON). Começaremos estabelecendo a arquitetura do nosso modelo. Tenha em mente que você pode jogar com alguns dos números para chegar a um modelo melhor! Aprendizado de máquinas baseia-se principalmente em tentativa e erro.
8. Treinamento e economia de modelos
É hora de treinar nosso modelo em nossos dados agora que o configuramos! Conseguiremos isso ajustando nossos dados ao modelo. O número de épocas que fornecemos é o número de vezes que o modelo será exposto aos mesmos dados durante o treinamento.
Podemos salvar o modelo no modelo de arquivo assim que terminarmos de treiná-lo. tflearn é um script que pode ser usado em outros scripts.
9. Usando um chatbot
Agora você pode começar a conversar com seu bot.
Benefícios do Chatbot
- Como os bots devem operar 365 dias por ano, 24 horas por dia, sem remuneração, aumentam a disponibilidade e a velocidade de reação.
- Esses bots são ferramentas perfeitas para lidar com os três principais Vs do big data: volume, velocidade e variedade.
- Os chatbots são softwares que podem ser usados para conhecer e compreender os consumidores de uma empresa.
- Tem poder superior que tem um custo de manutenção barato depois de ter os principais benefícios.
- Os aplicativos de chatbot criam dados que podem ser preservados e utilizados para análises e previsões.
Caso de uso
- Resolvendo dúvidas de clientes
- Respondendo a perguntas frequentes
- Atribuindo clientes à equipe de suporte
- Coletando feedback do cliente
- Recomendar novas ofertas
- Loja com comércio conversacional
- IT Helpdesk
- Reserva de acomodações
- Transferência de dinheiro
Conclusão
Os chatbots, como outras tecnologias de IA, serão usados para aumentar as habilidades humanas e liberar os humanos para serem mais criativos e imaginativos, permitindo que gastem mais tempo em tarefas estratégicas do que táticas.
Empresas, funcionários e consumidores provavelmente se beneficiarão de recursos aprimorados de chatbot, como recomendações e previsões mais rápidas, bem como acesso fácil a videoconferência de alta definição a partir de uma conversa, em um futuro próximo, quando a IA for combinada com o desenvolvimento de Tecnologia 5G.
Essas e outras possibilidades ainda estão sendo investigadas, mas à medida que a conectividade com a Internet, a IA, a PNL e o aprendizado de máquina progridem, elas se tornarão mais prevalentes.
Chwoo
Olá,
Obrigado por este programa.
Eu tenho uma pergunta.
“bag_of_words” não está definido. Não consigo entender esse erro.
Você poderia me dizer como posso resolver esse erro??
Obrigado por este programa!! Tenha um bom dia
gaio
Adicione uma função antes de usar a seção do chatbot:
///////////////////////////////////////////////// /////////////////////////////
def bag_of_words(s, palavras):
bag = [0 for _ in range(len(palavras))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) para palavra em s_words]
para se em s_words:
para i, w em enumerar(palavras):
se w == se:
saco[i] = 1
return numpy.array(bolsa)
// Ele definitivamente resolverá seu problema. //
////////////////////////////////////////////////// //////////////////////////
Estou compartilhando o código completo com você, para que você tenha uma visão clara dele.
////////////////////////////////////////////////////// /////////
importar nltk
de nltk.stem.lancaster import LancasterStemmer
lematizador = LancasterStemmer()
importar numpy
importar tflearn
importar fluxo de tensor
importação aleatória
json de importação
importar picles
com open(“intents.json”) como arquivo:
dados = json.load(arquivo)
tente:
com open(“data.pickle”, “rb”) como f:
palavras, rótulos, treinamento, saída = pickle.load(f)
exceto:
palavras = []
rótulos = []
documentos_x = []
documentos_y = []
para intent em data[“intents”]:
para padrão na intenção[“padrões”]:
wrds = nltk.word_tokenize(padrão)
palavras.extend(wrds)
docs_x.append(wrds)
docs_y.append(intent["tag"])
se intent[“tag”] não estiver nos rótulos:
rótulos.append(intenção[“tag”])
words = [stemmer.stem(w.lower()) para w em palavras se w != “?”]
palavras = ordenado(lista(conjunto(palavras))))
rótulos = classificado(rótulos)
treinamento = []
saída = []
out_empty = [0 para _ no intervalo(len(rótulos))]
para x, doc em enumerate(docs_x):
bolsa = []
wrds = [stemmer.stem(w.lower()) para w em doc]
para w em palavras:
se w em wrds:
saco.apêndice(1)
outro:
saco.apêndice(0)
linha_saída = saída_vazia[:]
linha_saída[labels.index(docs_y[x])] = 1
training.append(bolsa)
saída.append(output_row)
treinamento = numpy.array(treinamento)
saída = numpy.array(saída)
com open(“data.pickle”, “wb”) como f:
pickle.dump((palavras, rótulos, treinamento, saída), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(shape=[Nenhum, len(treinamento[0])])
rede = tflearn.full_connected(rede, 8)
rede = tflearn.full_connected(rede, 8)
net = tflearn.fully_connected(net, len(output[0]), ativação=”softmax”)
rede = tflearn.regressão (rede)
modelo = tflearn.DNN(net)
tente:
model.load(“model.tflearn”)
exceto:
model.fit(treinamento, saída, n_epoch=1500, batch_size=8, show_metric=True)
model.save(“model.tflearn”)
def bag_of_words(s, palavras):
bag = [0 for _ in range(len(palavras))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) para palavra em s_words]
para se em s_words:
para i, w em enumerar(palavras):
se w == se:
saco[i] = 1
return numpy.array(bolsa)
def bate-papo():
print("Comece a falar com o bot (digite quit para parar)!")
enquanto True:
inp = input("Você: ")
if inp.lower() == “sair”:
quebrar
resultados = model.predict([bag_of_words(inp, palavras)])
índices_resultados = numpy.argmax(resultados)
tag = rótulos[results_index]
para tg em data[“intents”]:
if tg['tag'] == tag:
respostas = tg['respostas']
print(random.choice(respostas))
bater papo()
////////////////////////////////////////////////// ///////////////
Obrigado,
Feliz codificação!
Lu
Olá,
Poderia me dar uma ideia do processo a realizar no caso de querer criar um chatbot em python, mas a informação é obtida a partir de um inquérito em excel. Obrigado!