Sommario[Nascondere][Spettacolo]
Le chiamate vocali vengono gradualmente eliminate a favore di testo e immagini nel settore della comunicazione. Secondo un sondaggio di Facebook, più della metà degli acquirenti preferisce acquistare da un'azienda con cui parlare. La chat è diventata la nuova modalità di comunicazione socialmente accettabile.
Consente alle aziende di comunicare con i propri clienti in qualsiasi momento e da qualsiasi luogo. I chatbot stanno guadagnando sempre più popolarità tra aziende e clienti grazie alla loro facilità d'uso e ai tempi di attesa ridotti.
I chatbot, o programmi di conversazione automatizzati, forniscono ai clienti un metodo più personalizzato per accedere ai servizi tramite un'interfaccia testuale. I nuovi chatbot basati sull'intelligenza artificiale possono riconoscere una query (domanda, comando, ordine, ecc.) fatta da una persona (o un altro bot, inizio) in un ambiente specifico e rispondere in modo appropriato (risposta, azione, ecc.).
In questo post, esamineremo cosa sono i chatbot, i loro vantaggi, i casi d'uso e come crearne uno tuo apprendimento profondo chatbot in Python, tra le altre cose.
Iniziamo.
Allora, cosa sono i chatbot?
Un chatbot è spesso indicato come una delle forme più avanzate e promettenti di interazione uomo-macchina. Questi assistenti digitali migliorano l'esperienza del cliente semplificando le interazioni tra persone e servizi.
Allo stesso tempo, forniscono alle aziende nuove opzioni per ottimizzare il processo di contatto con i clienti per l'efficienza, che può ridurre le spese di supporto convenzionali.
In poche parole, è un software basato sull'intelligenza artificiale che ha lo scopo di comunicare con gli esseri umani nel loro linguaggio naturale. Questi chatbot interagiscono spesso tramite tecniche audio o scritte e possono facilmente imitare i linguaggi umani per connettersi con gli umani in modo simile a quello umano.
I chatbot imparano dalle loro interazioni con gli utenti, diventando più realistici ed efficienti nel tempo. Possono gestire un'ampia gamma di attività commerciali, come autorizzare la spesa, interagire con i consumatori online e generare lead.
Creare il tuo chatbot di deep learning con Python
Esistono molti tipi distinti di chatbot nel campo di machine learning e AI. Alcuni chatbot sono assistenti virtuali, mentre altri sono lì solo per conversare, mentre altri sono agenti del servizio clienti.
Probabilmente hai visto alcuni di quelli impiegati dalle aziende per rispondere alle domande. In questo tutorial creeremo un piccolo chatbot per rispondere alle domande più frequenti.
1. Installazione dei pacchetti
Il nostro primo passo è installare i seguenti pacchetti.
2. Dati di addestramento
Ora è il momento di capire che tipo di informazioni dovremo fornire al nostro chatbot. Non è necessario scaricare set di dati di grandi dimensioni perché si tratta di un semplice chatbot.
Utilizzeremo solo le informazioni che abbiamo creato noi stessi. Per seguire efficacemente la lezione, dovrai generare un file .JSON con lo stesso formato di quello visto di seguito. Il mio file si chiama "intents.json".
Il file JSON viene utilizzato per creare una serie di messaggi che è probabile che l'utente inserisca e che associ a una serie di risposte pertinenti. Ogni dizionario nel file ha un tag che identifica a quale gruppo appartiene ogni messaggio.
Useremo queste informazioni per addestrare a rete neurale per classificare una frase di parole come uno dei tag nel nostro file.
Possiamo quindi semplicemente prendere una risposta da quei gruppi e fornirla all'utente. Il chatbot sarà migliore e più complicato se lo offri con tag, risposte e schemi aggiuntivi.
3. Caricamento dei dati JSON
Inizieremo caricando i nostri dati .json e importando alcuni moduli. Assembla il tuo file.json nella stessa directory del tuo Script Python. I nostri dati .json verranno ora salvati nella variabile data.
4. Estrazione dei dati
Ora è il momento di estrarre le informazioni di cui abbiamo bisogno dal nostro file JSON. Tutti i pattern, nonché la classe/tag a cui appartengono, sono obbligatori.
Avremo anche bisogno di un elenco di tutti i termini univoci nei nostri modelli (per motivi che spiegheremo più avanti), quindi creiamo degli elenchi vuoti per tenere traccia di questi valori.
Ora esamineremo i nostri dati JSON e recupereremo le informazioni di cui abbiamo bisogno. Invece di averli come stringhe, useremo il tokenizer nltk.word per trasformare ogni modello in un elenco di parole.
Quindi, nel nostro elenco docs_x, aggiungeremo ogni modello, insieme al tag associato, all'elenco docs_y.
5. Stemming delle parole
Trovare la radice di una parola è noto come stemming. Ad esempio, la radice della parola "questo" potrebbe essere "quello", mentre la radice della parola "accadere" potrebbe essere "successo".
Useremo questa tecnica di stemming per ridurre il vocabolario del nostro modello e cercare di capire cosa implicano le frasi in generale. Questo codice genererà semplicemente un elenco univoco di parole derivate che verranno utilizzate nella fase successiva della nostra preparazione dei dati.
6. Borsa di parole
È tempo di parlare di un sacco di parole ora che abbiamo importato i nostri dati e generato un vocabolario derivato. Reti neurali e gli algoritmi di apprendimento automatico, come tutti sappiamo, richiedono un input numerico. Quindi la nostra lista di stringhe non la taglierà. Abbiamo bisogno di un meccanismo per rappresentare i numeri nelle nostre frasi, ed è qui che entra in gioco un sacco di parole.
Ogni frase sarà rappresentata da un elenco della lunghezza del numero di termini nel vocabolario del nostro modello. Ogni parola nel nostro vocabolario sarà rappresentata da un posto nell'elenco. Se la posizione nell'elenco è un 1, la parola appare nella nostra istruzione; se è uno 0, la parola non compare nella nostra frase.
Lo chiamiamo sacco di parole perché non conosciamo la sequenza in cui le parole compaiono nella frase; tutto ciò che sappiamo è che esistono nel vocabolario del nostro modello.
Oltre a strutturare il nostro input, dobbiamo anche formattare il nostro output in modo che la rete neurale lo capisca. Creeremo elenchi di output che sono la lunghezza del numero di etichette/tag nel nostro set di dati, simili a un sacco di parole. Ogni posizione nell'elenco rappresenta un'etichetta/tag univoca e un 1 in una di queste posizioni indica quale etichetta/tag viene rappresentato.
Infine, utilizzeremo gli array NumPy per archiviare i nostri dati di addestramento e l'output.
7. Sviluppo del modello
Siamo pronti per iniziare a creare e addestrare un modello ora che abbiamo preelaborato tutti i nostri dati. Utilizzeremo una rete neurale feed-forward molto semplice con due livelli nascosti per i nostri obiettivi.
Lo scopo della nostra rete sarà esaminare una raccolta di parole e assegnarle a una classe (uno dei nostri tag dal file JSON). Inizieremo stabilendo l'architettura del nostro modello. Tieni presente che puoi giocare con alcuni dei numeri per trovare un modello migliore! apprendimento automatico si basa principalmente su tentativi ed errori.
8. Formazione e risparmio sui modelli
È ora di addestrare il nostro modello sui nostri dati ora che lo abbiamo impostato! Ci riusciremo adattando i nostri dati al modello. Il numero di epoche che forniamo è il numero di volte in cui il modello sarà esposto agli stessi dati durante l'addestramento.
Possiamo salvare il modello nel modello di file una volta terminato l'addestramento. tflearn è uno script che può essere utilizzato in altri script.
9. Utilizzo di un chatbot
Ora puoi iniziare a chattare con il tuo bot.
Vantaggi di Chatbot
- Poiché i bot dovrebbero funzionare 365 giorni all'anno, 24 ore al giorno, senza retribuzione, aumenta la disponibilità e la velocità di reazione.
- Questi bot sono strumenti perfetti per affrontare le tre V principali dei big data: volume, velocità e varietà.
- I chatbot sono software che possono essere utilizzati per conoscere e comprendere i consumatori di un'azienda.
- Ha una potenza superiore che ha un costo di manutenzione economico dopo aver ottenuto i massimi vantaggi.
- Le applicazioni Chatbot creano dati che possono essere conservati e utilizzati per analisi e previsioni.
Caso d'uso
- Risolvere le domande dei clienti
- Rispondere alle domande più frequenti
- Assegnazione dei clienti al team di supporto
- Raccolta dei feedback dei clienti
- Raccomandazione di nuove offerte
- Acquista con il commercio conversazionale
- Helpdesk IT
- Prenotazione alloggi
- Trasferimento di denaro
Conclusione
I chatbot, come altre tecnologie di intelligenza artificiale, verranno utilizzati per aumentare le capacità umane e liberare gli esseri umani in modo che siano più creativi e fantasiosi consentendo loro di dedicare più tempo a compiti strategici piuttosto che tattici.
È probabile che aziende, dipendenti e consumatori traggano vantaggio dalle funzionalità avanzate dei chatbot come consigli e previsioni più rapidi, nonché un facile accesso alle videoconferenze ad alta definizione dall'interno di una conversazione, nel prossimo futuro, quando l'IA si combina con lo sviluppo di Tecnologia 5G.
Queste e altre possibilità sono ancora oggetto di studio, ma con il progresso della connettività Internet, dell'IA, della PNL e dell'apprendimento automatico, diventeranno più prevalenti.
Chwoo
Ciao,
Grazie per questo programma.
Ho una domanda.
“bag_of_words” non è definito. Non riesco a capire questo errore.
Sapreste dirmi come posso risolvere questo errore??
Grazie per questo programma!! Buona giornata
Jay
Si prega di aggiungere una funzione prima di utilizzare la sezione chatbot:
////////////////////////////////////////////////// /////////////////////////////
def bag_of_words(s, parole):
borsa = [0 for _ in range(len(words))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) per la parola in s_words]
per se in s_words:
per i, w in enumera(parole):
se w == se:
borsa[i] = 1
restituisci numpy.array (borsa)
// Risolverà sicuramente il tuo problema. //
////////////////////////////////////////////////// //////////////////////////
Condivido il codice completo con te, così ne avrai un quadro chiaro.
//////////////////////////////////////////////// // ///////
importa nltk
da nltk.stem.lancaster importa LancasterStemmer
stemmer = LancasterStemmer()
importare numpy
importare tflearn
importa flusso tensoriale
importazione casuale
importa json
sottaceto di importazione
con open("intents.json") come file:
dati = json.load(file)
provare:
con open(“data.pickle”, “rb”) come f:
parole, etichette, formazione, output = pickle.load(f)
ad eccezione di:
parole = []
etichette = []
documenti_x = []
documenti_y = []
per intento nei dati["intenti"]:
per pattern in intent[“pattern”]:
wrds = nltk.word_tokenize(modello)
parole.extend(wrds)
docs_x.append(wrds)
docs_y.append(intent["tag"])
se intent["tag"] non nelle etichette:
etichette.append(intent["tag"])
parole = [stemmer.stem(w.lower()) for w in words if w != “?”]
parole = ordinato(lista(set(parole)))
etichette = ordinato(etichette)
formazione = []
uscita = []
out_empty = [0 for _ in range(len(etichette))]
per x, doc in enumerate(docs_x):
borsa = []
wrds = [stemmer.stem(w.lower()) per w nel doc]
per w in parole:
se w in wrds:
borsa.append(1)
altro:
borsa.append(0)
riga_output = vuoto_esterno[:]
riga_output[labels.index(docs_y[x])] = 1
training.append (borsa)
output.append(riga_output)
formazione = numpy.array(formazione)
output = numpy.array (output)
con open(“data.pickle”, “wb”) come f:
pickle.dump((parole, etichette, formazione, output), f)
tensorflow.reset_default_graph()
net = tflearn.input_data(shape=[Nessuno, len(training[0])])
net = tflearn.full_connected(net, 8)
net = tflearn.full_connected(net, 8)
net = tflearn.full_connected(net, len(output[0]), activation=”softmax”)
netto = tflearn.regression(netto)
modello = tflearn.DNN(net)
provare:
model.load ("model.tflearn")
ad eccezione di:
model.fit(formazione, output, n_epoch=1500, batch_size=8, show_metric=True)
modello.save("modello.tflearn")
def bag_of_words(s, parole):
borsa = [0 for _ in range(len(words))]
s_words = nltk.word_tokenize(s)
s_words = [stemmer.stem(word.lower()) per la parola in s_words]
per se in s_words:
per i, w in enumera(parole):
se w == se:
borsa[i] = 1
restituisci numpy.array (borsa)
chat def():
print("Inizia a parlare con il bot (digita quit to stop)!")
mentre vero:
inp = input("Tu:")
if inp.lower() == “chiudi”:
rompere
risultati = model.predict([bag_of_words(inp, words)])
indice_risultato = numpy.argmax(risultati)
tag = etichette[results_index]
per tg in data[“intents”]:
if tg['tag'] == tag:
risposte = tg['risposte']
print(random.choice(risposte))
Chiacchierare()
/ / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /
Grazie,
Buona programmazione!
Lu
Ciao,
Potresti darmi un'idea del processo da eseguire nel caso in cui volessi creare un chatbot in python, ma le informazioni sono ottenute da un sondaggio in excel. Grazie!