Intelligentes Marketing mit Django, Rasa NLU und Vonage

Moderne Unternehmen setzen auf intelligente Technologien wie Chatbots, um Arbeitsabläufe zu automatisieren. Intelligente Technologie kann Dinge wie Buchhaltung, Rekrutierung und Marketing automatisieren. Mithilfe von künstlicher Intelligenz können Unternehmen ihre Arbeit erleichtern und die Kundenbindung und -interaktion verbessern. Das beste Beispiel für den Einsatz intelligenter Technologien sind virtuelle Assistenten und Chatbots. Diese intelligenten Werkzeuge helfen Unternehmen, produktiver zu sein, ohne die gesamte Arbeit manuell erledigen zu müssen.

Voraussetzungen

Für diese Anwendung werden wir die folgenden Elemente verwenden:

Django - Ein Web-Framework für die Webentwicklung

Rasa NLU - Eine Open-Source-Plattform für natürliche Sprachverarbeitung

Django Rest Framework - Ein Django-Paket, das zur Erstellung von APIs verwendet wird

Angularjs x 1 - Ein Javascript-Frontend-Framework

Vuejs x 1 - Ein Javascript-Frontend-Framework

Docker - Eine Container-Image-Plattform

Heroku - Eine Webhosting-Plattform

Vonage-SMS-API - Eine API für den Versand von SMS-Textnachrichten

Als nächstes werden wir uns ansehen, wie jedes dieser Pakete zu installieren ist.

Einrichtung

Zunächst werden wir eine virtuelle Umgebung installieren. Eine virtuelle Umgebung ist wie ein Lagerhaus für alle unsere Pakete. Da wir Linux verwenden, gehen Sie zu cmd und geben Sie ein virtualenv vonenv.

Dadurch wird eine neue virtuelle Umgebung namens vonenv. Aktivieren Sie diese durch Eingabe von source/vonenv/bin/activate.

Installieren von Django

Wir werden Django als unser App-Framework verwenden. Installieren Sie Django durch Eingabe von pip install Django. Sie können die Version angeben, indem Sie == und den Namen der Version angeben.

Installation des Django Rest Frameworks

Typ pip install Django rest framework. Installieren Sie außerdem den Python-Scheduler durch Eingabe von pip install scheduler.

Installation von Django-cors-headers

Wir installieren ein Paket namens django-cors-headers das dazu beiträgt, Cross-Origin-Fehler zu verhindern. Das bedeutet, dass wir in der Lage sein werden, HTTP-Anfragen von einem Server zum anderen zu senden und zu empfangen. Um das Paket zu installieren, geben Sie ein:

pip install django-cors-headers

Unsere App erstellen

Um die Anwendung zu erstellen, geben Sie ein django-admin startproject vonage. Dadurch wird unser Projekt Boilerplate mit dem gesamten Code erstellt.

Navigieren Sie zu Ihrer Anwendung und geben Sie django-admin start project myapp. Dadurch wird unser Projekt erstellt, das wir verwenden werden.

Um die Anwendung zu testen, geben Sie einfach python manage.py runserver ein und navigieren Sie zu localhost:8000 in Ihrem Browser.

Einstellungen konfigurieren

Navigieren Sie zum Stammverzeichnis Ihres Projekts und öffnen Sie die Datei settings.py. Dies ist die Datei, mit der die Backend-Konfiguration unserer Anwendung eingerichtet wird.

In der Liste der installierten Anwendungen fügen Sie myapp und rest framework am Ende hinzu. Damit werden die Pakete registriert und Django mitgeteilt, dass wir sie verwenden möchten.

Im Terminal ausführen, python manage.py migrate. Dadurch werden die ersten Migrationen unserer Anwendung durchgeführt und neue Tabellen in der Datenbank erstellt.

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = [
   'django.contrib.admin',
   'django.contrib.auth',
   'django.contrib.contenttypes',
   'django.contrib.sessions',
   'django.contrib.messages',
   'django.contrib.staticfiles',
   'django.contrib.sites',
   'myapp',
   'actstream',
   'rest_framework',
   'corsheaders',
]
SITE_ID = 1

Modelle konfigurieren

Als nächstes müssen wir unsere Datenbankmodelle erstellen. Modelle sind die Tabellen, die wir in der Datenbank auffüllen werden. Wir werden zwei Modelle erstellen, nämlich TextMessage und UserActivity. Das Modell "TextMessage" wird zum Speichern der Details des Textnachrichtenobjekts verwendet und das Modell "UserActivity" zum Speichern und Verfolgen der Benutzeraktivitäten.

from django.db import models
from django.contrib.auth import get_user_model
from django.db.models.signals import post_save
from actstream import action
from django.utils import timezone
# Create your models here.
class TextMessage(models.Model):
   user = models.ForeignKey(get_user_model(),on_delete=models.CASCADE)
   ffrom= models.IntegerField()
   to= models.IntegerField()
   text = models.CharField(max_length=1000)
   text_type = models.CharField(max_length=100,default='sms',blank=True)
   send_date = models.DateField(default='2020-12-12')
   send_time = models.TimeField()
   date_created = models.DateField(auto_now=True)

class UserActivity(models.Model):
   user = models.ForeignKey(get_user_model(),on_delete=models.CASCADE)
   verb = models.CharField(max_length=100)
   target = models.CharField(max_length=1000)
   time_stamp = models.DateField(auto_now=True)

Erstellen unserer API

API steht für Anwendungsprogrammierschnittstelle. Es handelt sich um eine Reihe von Protokollen (Regeln), die festlegen, wie Sie auf Daten zugreifen und sie verwenden können. Eine REST-API verwendet zum Beispiel GET/POST/DELETE/PUT. Dies sind die Protokolle einer REST-API. Eine API ermöglicht den Zugriff auf Daten in einer Datenbank über HTTP-Anfragen.

Wir werden zwei REST-APIs erstellen, TextMessage-API und UserActivity-API. Warum APIs verwenden? Eine API ist wichtig, um HTTP-Anfragen zu stellen und die Interaktion mit der Datenbank zu erleichtern. Mit APIs können wir HTTP-Anforderungen an unsere API-Endpunkte stellen und jedes beliebige JavaScript-Framework verwenden. Das macht unsere Frontend-Auswahl flexibel und einfacher zu integrieren.

Falls Sie dies noch nicht getan haben, installieren Sie das Django REST-Framework-Paket durch Eingabe von pip install Django-rest-framework. Fügen Sie dann das Paket zu den installierten Anwendungen hinzu und führen Sie python manage.py migrate um die Änderungen in unserer Datenbank zu registrieren.

Ansichten konfigurieren

Die Datei views wird für die Speicherung unserer Funktionen zuständig sein. Diese Funktionen werden in der Lage sein, Daten zu rendern, Fehler abzufangen und GET-, POST-, PUT-, EDIT- und DELETE-Anfragen an unsere APIs zu stellen.

Wir müssen einige Funktionen und Methoden importieren, die von unseren Funktionen und Klassen verwendet werden. Dies sind integrierte Methoden aus unseren installierten Paketen, einschließlich Django.

from django.shortcuts import render
from .models import TextMessage, UserActivity
from .serializers import TextMessageSerializer, UserActivitySerializer
from django.http import Http404
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from django.utils.decorators import method_decorator
from django.http import HttpResponse
import schedule
from django.views.generic.detail import DetailView
from django.contrib.auth import login, authenticate
from django.contrib.auth.forms import UserCreationForm
from django.http import Http404, HttpResponseRedirect
import datetime
import requests

Landing Page Ansicht

#landing page
def landing(request):
   return render(request,'myapp/landing.html')

Diese Funktion rendert unsere Landing Page-Vorlage.

Dashboard Seitenansicht

#dashboard view
def index(request):
   act = UserActivity.objects.all()
   return render(request,'index.html',{'act':act})

Diese Funktion rendert unsere Dashboard-Seitenvorlage.

SMS-Planung

Wir werden die SMS mit einem Django-Paket namens python scheduler planen. Wir verwenden dieses Paket, da es einfach einzurichten und effizient ist.

# extract dates and time from model
sms = TextMessage.objects.all()
for s in sms:
   date_to_send = s.send_date
   date_created = s.date_created
   days_left = date_created - date_to_send ,s.send_time
   print(days_left)
   days_left = str(days_left)
   daytime = str(s.send_time)

Diese Funktion ist für den Versand der SMS an den Empfänger zuständig. Sie verwendet die Anforderungsbibliothek, um Post-Anforderungen an den Vonage-API-Endpunkt zu stellen und dabei Daten aus der TextMessage-API als Parameter zu verwenden. Wenn die Funktion aufgerufen wird, sendet sie die SMS unter Verwendung von Daten aus der TextMessage-API.

# here I used my own credentials for demo purposes
def job():
   r = requests.post("https://rest.nexmo.com/sms/json",data ={"from":s.ffrom,"text":s.text,"to":s.to,"api_key":"[YOUR API KEY]", "api_secret":"[YOUR API SECRET]"})
   print(r)

sms = TextMessage.objects.all()
for s in sms:
   date_to_send = s.send_date
   date_created = s.date_created
   days_left = date_created - date_to_send ,s.send_time
   print(days_left)
   total_days = str(days_left)
   daytime = str(s.send_time)
   #schedule each sms
   schedule.every(total_days).days.at(daytime).do(job)

URLs konfigurieren

Die URL-Datei wird verwendet, um Routen für unsere App zu definieren. Wir werden die Ansichtsfunktionen als unsere Routen hinzufügen, um durch jede Vorlage zu navigieren.

from django.contrib import admin
from django.urls import path, include
from myapp import views

urlpatterns = [
   path('',views.landing,name='land'),
   path('signup',views.signup,name='signup'),
   path('dashboard',views.index,name='dash'),
   path('von',views.assistant,name='von'),
   path('schedule',views.timetable,name='sched'),
   path('text/<int:pk>',views.TextMessageDetailView.as_view(),name='detail'),
   path('api/texts', views.TextMessageList.as_view(),name='list'),
   path('api/texts/<int:pk>', views.TextMessageDetail.as_view(),name='api-detail'),
   path('api/activity', views.UserActivityList.as_view(),name='actions'),
   path('api/activity/<int:pk>', views.UserActivityDetail.as_view(),name='action-detail'),
   path('accounts/', include('django.contrib.auth.urls')),
   path('admin/', admin.site.urls),
]

Serialisierer

Bei der Verwendung von APIs müssen wir die Daten zunächst serialisieren. Unter Serialisierung versteht man die Umwandlung von Daten in kleine Bytes zur Verwendung durch Software oder physische Geräte. In unserem API-Framework ist es einfach, Daten zu serialisieren. Wir erstellen eine Datei serializers.py, importieren unsere Modelle und definieren unsere Serialisierer.

from rest_framework import serializers
from rest_framework.serializers import ModelSerializer
from .models import TextMessage,UserActivity

class TextMessageSerializer(serializers.ModelSerializer):
   class Meta:
	model = TextMessage
	fields = '__all__'

class UserActivitySerializer(serializers.ModelSerializer):
   class Meta:
	model = UserActivity
	fields = '__all__'

Templates konfigurieren

Da wir nun die Seiten kennen, die in unserer App verwendet werden, müssen wir unsere Vorlagen mit unseren Backend-Systemen verbinden. Dazu verwenden wir JavaScript und nutzen auch unsere APIs als Datenquelle.

Assistentin Seite

Diese Seite wird als unsere Chatbot-UI-Seite fungieren. Dies ist die Seite, die Benutzer verwenden werden, wenn sie mit unserem Chatbot sprechen und Daten übermitteln. Wir werden Angular verwenden, um mit unserem Bot zu interagieren, indem wir HTTP-Anfragen an die Rasa-API senden. Die Antwortdaten werden wir dann mit jQuery verwalten. Die Seite ist als Chat-Anwendung konzipiert, und alles, was der Benutzer tun muss, ist, die Fragen des Bots zu beantworten.

<script>
 //start chat on button click
 var app = angular.module('myApp', []);
app.controller('myCtrl', function($scope, $http,$interval) {
 $scope.sayHi = function(){
$http.post("http://localhost:5005/webhooks/rest/webhook",{"message":"hi"})
.then(function(response) {
   console.log(response.data)
   $(".chat").append("<br><li style='list-style:none;border 1px solid blue;padding:20px 20px 20px 20px;background-color:#3f5fa9;color:white;padding-right:30px;display:inline-block;width:700px;font-size:20px'>" + 'Start a campaign'+ "</li><br>")
  $(".chat").append("<br><li style='border 1px solid blue;padding:20px 20px 20px 20px;background-color:aqua;list-style:none;padding-right:30px;display:inline-block;width:700px;font-size:20px;float:right'>" + response.data[0].text + "</li><br>")
});
 }

})
//post user input to rasa api
$("#msg").click(function(){
axios.post("http://localhost:5005/webhooks/rest/webhook",{"message":$("#message").val()})
  .then(function (response) {
   $(".chat").append("<br><li class='human' style='list-style:none;border 1px solid blue;padding:20px 20px 20px 20px;background-color:#3f5fa9;color:white;padding-right:30px;display:inline-block;width:700px;font-size:20px'>" + $('input').val()+ "</li><br>")
  $(".chat").append("<br><li class='bot' style='border 1px solid blue;padding:20px 20px 20px 20px;background-color:aqua;list-style:none;padding-right:30px;display:inline-block;width:700px;font-size:20px;float:right'>" + response.data[0].text + "</li><br>")
 })
 .catch(function (error) {
   console.log(error);
 });

})
//post date to rasa api
$("#sub1").click(function(){
axios.post("http://localhost:5005/webhooks/rest/webhook",{"message":$("#date").val()})
  .then(function (response) {
 console.log(response)
   $(".chat").append("<br><li style='list-style:none;border 1px solid blue;padding:20px 20px 20px 20px;background-color:#3f5fa9;color:white;padding-right:30px;display:inline-block;width:700px;font-size:20px'>" + $("#date").val() + "</li><br>")
  $(".chat").append("<br><li style='border 1px solid blue;padding:20px 20px 20px 20px;background-color:aqua;list-style:none;padding-right:30px;display:inline-block;width:700px;font-size:20px;float:right'>" + response.data[0].text + "</li><br>")
 .catch(function (error) {
   console.log(error);
 });
 })

})
//post time to rasa api
$("#sub2").click(function(){
axios.post("http://localhost:5005/webhooks/rest/webhook",{"message":$("#time").val()})
  .then(function (response) {
 console.log(response)
   $(".chat").append("<br><li style='list-style:none;border 1px solid blue;padding:20px 20px 20px 20px;background-color:#3f5fa9;color:white;padding-right:30px;display:inline-block;width:700px;font-size:20px'>" + $("#time").val() + "</li><br>")
  $(".chat").append("<br><li style='border 1px solid blue;padding:20px 20px 20px 20px;background-color:aqua;list-style:none;padding-right:30px;display:inline-block;width:700px;font-size:20px;float:right'>" + response.data[0].text + "</li><br>")
 .catch(function (error) {
   console.log(error);
 });
 })
})
</script>

 <script>
 //  open date and time modal on chat click
 $("ul").click(function(){
 $("#op").click()
   $("#op2").click()
})
</script>

Zeitplan Seite

Auf dieser Seite werden alle geplanten SMS in unserer Datenbank angezeigt. Der Benutzer kann die Daten in der Datenbank verfolgen und jede SMS im Detail ansehen, indem er auf einen der Werte klickt. Wenn der Benutzer auf die Schaltfläche "Anzeigen" klickt, wird er auf die Detailseite der SMS weitergeleitet. Auf dieser Seite verwenden wir Vue.js, um eine einfache HTTP-GET-Anfrage an unsere API auf localhost:8000 zu stellen.

<!--render api data-->

 <h2 class="mb-4">Schedule</h2>
<!--wrap vuejs syntax in verbatim tag as data will not render outside the verbatim tag-->
{% verbatim  %}
   <table id="app" class="table">
   <thead>
 <tr style="color:blue">
   	<b><td>ID</td></b>
	<b><td>TO</td></b>
	<b><td>FROM</td></b>
   <b><td>MESSAGE</td></b>
	<b><td>DATE</td></b>
  </tr>
  <tr v-for="stat in info">
   	<td>{{stat.id}}</td>
	<td>{{stat.to}}</td>
	<td>{{stat.ffrom}}</td>
	<td>{{stat.text}}</td>
	<td>{{stat.send_date}}</td>
	<td>{{stat.send_time}}</td>
	<td>{{stat.date_created}}</td>
  </tr>
   </tbody>
 </table>
  {% endverbatim %} </div>
 </div>
	</div>
<!--script to get api data-->
 <script>
new Vue({
 el: '#app',
 data () {
   return {
  info: null
   }
 },
 mounted () {
   axios
  .get('/api/texts')
  .then(response => (this.info = response.data))

 }
})
 </script>

Dashboard Seite

Dies ist die Seite, die alle Nutzeraktivitäten in der App aufzeichnet. In dieser App sieht der Nutzer alle seine Aktivitätsströme und die entsprechenden Daten. Dies ist wichtig, damit der Benutzer eine Referenz für das, was er an einem bestimmten Datum und zu einer bestimmten Uhrzeit getan hat, haben kann. Die Aktivitäten werden mit der Django-Syntax für Templates und die Aktionen über die Views dargestellt.

<h2 class="mb-4">Activity Dashboard</h2>


<!--loop through actions-->


{% for a in act %}


<h3>{{a.user}} {{a.verb}} <span style="color:blue">{{a.target}}</span> at {{a.time_stamp}}</h3>
{% endfor %}

Login-Seite

Auf dieser Seite kann sich der Benutzer mit einem Benutzernamen und einem Passwort bei der App anmelden oder registrieren.

Anmeldeseite

Auf dieser Seite, die auch als Registrierungsseite bezeichnet wird, kann der Nutzer einen neuen Account erstellen. Nach der Authentifizierung hat die Seite Zugriff auf die anderen Seiten.

Testen der App

Nun, da wir alles angeschlossen haben, was wir zum Ausführen unserer Django-Anwendung benötigen, müssen wir nur noch sehen, ob alles gut funktioniert. Geben Sie im Terminal python manage.py runserver ein und navigieren Sie zu localhost:8000. Navigieren Sie mit den seitlichen Navigationsschaltflächen, um zu sehen, wie die einzelnen Seiten aussehen. Da wir noch keine Daten in unsere Datenbank eingegeben haben, werden keine Daten angezeigt. Das Anklicken der Schaltflächen wird ebenfalls nicht funktionieren, da wir unser Frontend-System noch nicht mit der Rasa-API verbunden haben. Nun, da das Design fertig ist, können wir mit der Entwicklung unseres Rasa-Bots beginnen.

Installation von Rasa

Rasa ist eine Open-Source-KI-Plattform, die es Entwicklern ermöglicht, mithilfe einer Reihe von KI-APIs ihre eigenen Chatbots und Sprachassistenten zu erstellen. Rasa verwendet viel natürliche Sprachverarbeitung (NLP) und ist daher am besten für die Erstellung von NLP-Anwendungen geeignet. Wir werden Rasa verwenden, um unser eigenes benutzerdefiniertes KI-Chatbot-Backend zu erstellen, das in unsere Benutzeroberfläche integriert wird.

Um Rasa zu installieren, öffnen Sie ein neues Terminal und erstellen Sie eine neue virtuelle Umgebung oder reaktivieren Sie die vorherige. Geben Sie dann pip install rasa. Dieser Befehl lädt Rasa von der Rasa-Website herunter und installiert es auf Ihrem Rechner. Nach der Installation steht Ihnen ein einfacher Bot zur Verfügung, mit dem Sie sprechen können. Geben Sie im selben Terminal rasa shell ein, um mit Ihrem Bot zu kommunizieren. Geben Sie hi oder hello ein und drücken Sie die Eingabetaste. Der Bot wird entsprechend seinem Training reagieren.

Domäne konfigurieren

Lassen Sie uns nun unseren Bot so programmieren, dass er auf unseren Anwendungsfall hier reagiert. Das Ziel unseres Bots ist es, Benutzerdaten aufzunehmen und sie in einer Datenbank zu speichern. Die Daten werden dann verwendet, um zu einem bestimmten Zeitpunkt eine SMS an eine bestimmte Nummer zu senden. Wir müssen also unseren Bot so konfigurieren, dass er Daten aufzeichnet. Mithilfe von NLP kann der Bot angemessen reagieren und einem bestimmten Antwortfluss folgen.

Öffnen Sie die Domänendatei, und Sie werden darin einige Überschriften sehen. Die Überschriften lauten Intents, Actions und Templates. Diese müssen wir ändern, damit die Bot-Antwort spezifisch und relevant für unsere Anwendung ist. Zum Beispiel fügen wir intent ask_message und ask_recipient_number hinzu, damit der Bot erkennen kann, dass die Eingabe die Empfängernummer ist.

Wir müssen auch Slots und Entitäten zu unserer Datei hinzufügen. Slots sind die Eingabefelder, die vom Bot bei der Dateneingabe verwendet werden. Anstatt einfach zu antworten, speichert der Bot die Daten als Formulareingabe und sendet sie ab, wenn er fertig ist.

slots:
 from:
   type: text
 to:
 type: text
 message:
  type: text
 send_time:
  type: unfeaturized
 send_date:
  type: unfeaturized

entities:
 - from
 - to
 - message
 - send_time
 - send_date

intents:
 - greet
 - affirm
 - deny
 - from
 - to
 - message
 - send_time
 - send_date

forms:
 - text_form

actions:
- action_ask_details
- utter_ask_from
- utter_ask_to
- utter_affirm
- utter_deny
- utter_respond
- utter_ask_message
- utter_ask_send_time
- utter_ask_send_date

templates:
 utter_ask_from:
 - text: "Hello! Welcome to Vonage marketing. To begin please provide the number to send from?"

 utter_ask_to:
 - text: "Which number should I send to?"

 utter_ask_message:
 - text: "What's your message text?"

 utter_affirm:
 - text: "Good! Your data has been saved"

 utter_deny:
 - text: "Oh sorry to hear that. Please refresh your page to try again"

 utter_respond:
 - text: "I will now be scheduling your sms. You provided the following data:
   	From: {from} To: {to} Message: {message} Date: {send_date} Time: {send_time}. Is this correct?"

 utter_ask_send_time:
 - text: "Click here to schedule the time"

 utter_ask_send_date:
 - text: "Click here to select date"
   buttons:
   - title: "Select date"
  payload: '/send_date{"send_date": "send_date"}'

Geschichten konfigurieren

Geschichten beziehen sich auf die Benutzereingaben, die der Benutzer machen kann. Wir sagen dem Bot zum Beispiel, dass er von einem Benutzer eine Telefonnummer 55512345 oder eine ähnliche Nummer erwarten soll, damit der Bot mit den Benutzereingaben vertraut ist. Wir schreiben die Geschichten und geben an, auf welchen Slot sie sich beziehen. Slots sind Eingaben für das Formular.

## happy path
* greet
 - utter_ask_from
 - text_form
 - form{"name": "text_form"}
 - slot{"requested_slot": "from"}
 - slot{"from": "350123456789"}
 - slot{"from": "230123456789"}
 - slot{"from": "263123456789"}
 - slot{"from": "299123456789"}
 - slot{"from": "502123456789"}
 - slot{"from": "224123456789"}
 - slot{"from": "592123456789"}
 - form{"name": "text_form"}
 - slot{"requested_slot": "to"}
 - slot{"to": "350123456789"}
 - slot{"to": "230123456789"}
 - slot{"to": "263123456789"}
 - slot{"to": "299123456789"}
 - slot{"to": "502123456789"}
 - slot{"to": "224123456789"}
 - slot{"to": "592123456789"}
 - form{"name": "text_form"}
 - slot{"requested_slot": "message"}
 - slot{"message": "welcome to team vonage!"}
 - slot{"message": "thank you for subscribing!"}
 - slot{"message": "buy one and get one extra for free"}
 - slot{"message": "this is a marketing sms!"}
 - slot{"message": "thank you for contacting us!"}
 - slot{"message": "we will holding a team conference next week,dont miss out!"}
 - slot{"message": "zoom meeting next week!"}
 - form{"name": "text_form"}
 - slot{"requested_slot": "send_time"}
 - slot{"send_time": "13:30"}
 - slot{"send_time": "23:01"}
 - slot{"send_time": "23:31"}
 - slot{"send_time": "2:12"}
 - slot{"send_time": "5:00"}
 - slot{"send_time": "22:41"}
 - form{"name": "text_form"}
 - slot{"requested_slot": "send_date"}
 - slot{"send_date": "12-12-2020"}
 - slot{"send_date": "11-09-2020"}
 - slot{"send_date": "20-01-2021"}
 - slot{"send_date": "20-01-2021"}
 - slot{"send_date": "20-01-2021"}
 - slot{"send_date": "20-01-2021"}
 - slot{"send_date": "20-01-2021"}
 - utter_respond

## happy path 2
* affirm
 - utter_affirm

## sad path 1
* deny
 - utter_deny

NLU konfigurieren

In die NLU-Datei schreiben wir die Absichten des Benutzers und Beispiele für jede Absicht. Es ist ratsam, so viele Beispiele wie möglich für jede Absicht zu schreiben, damit der Bot intelligenter wird und mehr Eingaben erkennen kann.

## intent:from
- [350123456789](from)
- [230123456789](from)
- [263123456789](from)
- [299123456789](from)
- [502123456789](from)
- [224123456789](from)
- [592123456789](from)

## intent:to
- [350123456789](to)
- [230123456789](to)
- [263123456789](to)
- [299123456789](to)
- [502123456789](to)
- [224123456789](to)
- [592123456789](to)

## intent:message
- are you a bot?
- are you a human?
- am I talking to a bot?
- am I talking to a human?

## intent:send_time
- [13:30](send_time)
- [23:01](send_time)
- [21:31](send_time)
- [2:12](send_time)
- [5:00](send_time)
- [22:41](send_time)
- [5:00](send_time)

## intent:send_date
- [12-12-2020](send_date)
- [11-09-2020](send_date)
- [20-01-2021](send_date)
- [20-01-2021](send_date)
- [20-01-2021](send_date)
- [20-01-2021](send_date)
- [20-01-2021](send_date)

Aktionen konfigurieren

In der Aktionsdatei stellen wir nun alle Daten zusammen und entscheiden, wie die Benutzereingaben verarbeitet werden sollen. In unserem Fall nehmen wir die Benutzereingaben als Formulardaten entgegen, so dass wir die vom Benutzer eingegebenen Daten übermitteln müssen. Diese Daten werden an die TextMessage-API gesendet, die wir in diesem Beitrag bereits erstellt haben. Die Daten werden als Parameter in der Vonage Messages API verwendet, wenn eine POST-Anfrage gestellt wird.

Konfig-Datei

Bevor wir fortfahren, müssen wir Rasa mitteilen, dass wir Antworten in einem Formularformat entgegennehmen. Öffnen Sie dazu config.yml und fügen Sie FormPolicy am Ende der Richtlinienliste hinzu. Richtlinien sind insofern wichtig, als sie dem Bot mitteilen, wie die Daten zu verwenden sind, welches Format zu verwenden ist und die Art des Datenflusses bestimmen. In diesem Fall ist der Datenfluss der eines Formulars.

# Configuration for Rasa NLU.
# https://rasa.com/docs/rasa/nlu/components/
language: en
pipeline: supervised_embeddings

# Configuration for Rasa Core.
# https://rasa.com/docs/rasa/core/policies/
policies:
 - name: MemoizationPolicy
 - name: KerasPolicy
 - name: MappingPolicy
 - name: FormPolicy

Nachdem wir nun alles konfiguriert haben, was wir zum Trainieren unseres Bots benötigen, trainieren wir den Bot so, dass er alle unsere benutzerdefinierten Konfigurationen aus jeder Datei verwendet. Geben Sie also im Terminal ein rasa train. Der Bot braucht ein paar Sekunden, um die Änderungen zu analysieren, zu überprüfen und auf den Bot anzuwenden. Bei einem Fehler in den Dateien wird das Training nicht funktionieren.

Testen des neuen Bots

Nun ist es an der Zeit, unsere Bot-Konfiguration zu testen. Öffnen Sie ein neues Terminalfenster und geben Sie rasa run actions.

In einem anderen Terminaltyp rasa shell. Wir werden eine Shell verwenden, um den Bot zu testen. Geben Sie in der Shell hi ein und beantworten Sie die Fragen des Bots. Wenn alles in Ordnung ist, sollte Ihr Bot Ihnen eine Frage nach der anderen stellen und alle Daten aufnehmen. Das ist die FormPolicy in Aktion. Sobald Sie alle Informationen eingegeben haben, übermittelt der Bot die Daten über die in der Datei actions.py konfigurierten Anfragen an Ihre REST-API.

Verbindung zwischen Rasa und Django

Wir haben endlich unsere Django-App und unseren Rasa-Bot fertiggestellt, aber jetzt müssen wir die beiden miteinander verbinden, damit unser Bot von unserem Django-Frontend aus genutzt werden kann. Wir müssen nur ein paar Dinge in unserem JavaScript-Code ändern. Wir werden HTTP-POST-Anfragen an unseren Bot stellen und die Antwortdaten anzeigen.

In dem Terminal, in dem wir die Rasa-Shell geöffnet haben, müssen wir nun den Rasa-Server für HTTP-Anfragen mit dem folgenden Befehl starten:

rasa run -m-enable-api --cors ''*' --debug

Mit diesem Befehl wird sichergestellt, dass Rasa HTTP-Anfragen von einem Remote-Server über unseren REST-Kanal empfangen kann.

Im Terminal müssen nun 3 Server laufen, einer für Rasa Actions, Rasa HTTP und Django Server für das Frontend.

Navigieren Sie zur URL localhost:8000/von auf der sich unsere Bot-Benutzeroberfläche befindet, und klicken Sie auf Kampagne starten. Dadurch wird eine HTTP-POST-Anfrage an Rasa gesendet, indem Sie Hallo sagen. Sie werden die Antwort des Bots in der Benutzeroberfläche sehen.

Wir können nun mit unserem Bot interagieren, indem wir das Eingabefeld am unteren Rand verwenden. Beantworten Sie die Frage des Bots, indem Sie eine Zahl eingeben und auf "Senden" klicken. Der Bot startet eine Sequenz, in der er jede Eingabe in den Formularfeldern speichert und an unsere TextMessage REST API sendet.

Wenn Sie das Django-Terminal öffnen, werden Sie sehen, dass eine HTTP-POST-Anfrage erfolgreich an api/textedurchgeführt wurde, was bedeutet, dass unser Formular erfolgreich abgeschickt wurde! Anhand der Uhrzeit und des Datums, die Sie an den Bot übermittelt haben, sollten Sie eine SMS an die von Ihnen angegebene Empfängernummer erhalten.

Unsere App ist jetzt funktionsfähig, aber wir müssen noch ein paar Dinge ändern. Im Moment ist die App nur auf unseren lokalen Rechnern verfügbar. Daher müssen wir sie für die Öffentlichkeit zugänglich machen. Wir werden Heroku für die Django-Bereitstellung und Docker-Container für die Bot-Bereitstellung verwenden.

Bereitstellen auf Heroku

In diesem Beitrag werden wir uns nur auf die Bereitstellung der App konzentrieren und nicht auf die Besonderheiten von Heroku eingehen. Als Erstes müssen Sie einen Heroku Account erstellen, also gehen Sie zu https://www.heroku.com um einen kostenlosen Account zu erstellen.

Nachdem wir den Account erstellt haben, müssen wir Heroku auf unserem Rechner installieren, damit wir es vom Terminal aus nutzen können. Sobald Sie Ihren Account erstellt haben, gehen Sie zu https://devcenter.heroku.com/articles/heroku-cli und folgen Sie den Anweisungen zur Installation der CLI, die auf Ihrem Betriebssystem basiert.

Als Nächstes müssen Sie sich bei Heroku über die CLI anmelden, da dies viel einfacher ist. Wenn alles ordnungsgemäß installiert ist, können wir jetzt unsere Django-App auf Heroku bereitstellen.

Bevor wir uns mit Heroku beschäftigen, müssen wir Git für die Versionskontrolle installieren. Mit Git können wir alle Änderungen an unserer App verfolgen, ohne Daten zu verlieren.

Um Git zu installieren, navigieren Sie zu Ihrer Eingabeaufforderung und führen Sie den folgenden Befehl aus: sudo dnf install git-all. Sobald die Befehlsausgabe abgeschlossen ist, können Sie die Installation durch Eingabe von: git version.

Geben Sie in Ihrem Projektordner git initein, dann git add –all. Geben Sie dann ein:

git commit -m "commit message"

Mit diesen 3 Befehlen wird ein lokales Git-Repository auf Ihrem Rechner erstellt.

Es wird dringend empfohlen, Ihren Code sowohl online als auch offline zu speichern. Wir werden also alle unseren Code auf GitHub, ein Online-Repository, hochladen. Zuerst müssen wir einen GitHub Account erstellen, also gehen Sie zu https://github.com um loszulegen.

Sobald Sie Ihren Account erstellt haben, klicken Sie auf "Neues Repository" (nennen Sie es, wie Sie wollen) und klicken Sie auf "Mit einer README beginnen" und dann auf "Erstellen". Nun, da Ihr Repository erstellt wurde, können wir das GitHub-Repository mit unserem Django-Projekt verknüpfen.

Geben Sie in Ihrem Projektstammordner git remote add origin 'your/Github/URL'. Mit diesem Befehl wird das GitHub-Repository als entfernter Master-Zweig für Ihr Projekt hinzugefügt. Sobald dies geschehen ist, laden Sie Ihr Django-Projekt hoch, indem Sie eingeben:

git push origin master

Mit diesem Befehl werden Ihre Projektdateien in den Remote-Zweig master auf Github übertragen.

Jetzt müssen wir noch eine Sache tun, nämlich unsere App für Heroku konfigurieren. Wir müssen eine Procfile- und eine requirements.txt-Datei hinzufügen, also geben Sie in Ihrem Terminal echo>>Procfile und dann ein. pip freeze>requirements.txt

Öffnen Sie Procfile und fügen Sie Folgendes hinzu:

web: vonage.wsgi

Und das war's! Aktualisieren Sie Ihre Git- und GitHub-Repos entsprechend.

Einsatz

Für die Bereitstellung auf Heroku geben Sie nun heroku create vonbotein, damit wird Ihre Heroku-Anwendung erstellt.

Geben Sie als nächstes git push heroku master und Ihr Projekt wird auf Heroku hochgeladen.

Geben Sie heroku open ein, wodurch Ihr Projekt in einem Webbrowser geöffnet wird.

Bereitstellen auf Docker

Die letzte Aufgabe ist die Bereitstellung unseres Rasa-Projekts mit Docker.

Installation von Docker

Geben Sie im Terminal diese Befehle ein:

sudo apt-get update

sudo apt-get install docker-ce docker-ce-cli containerd.io

Dadurch wird Docker auf Ihrem Rechner installiert, wenn Sie Ubuntu verwenden. Für andere Betriebssysteme lesen Sie bitte die Anweisungen von Docker.

Bestätigen Sie anschließend die Installation durch Eingabe von sudo docker run hello-world.

Rasa Container

Anhand der Rasa-Dokumente werden wir unseren Bot mit docker-compose bereitstellen. Navigieren Sie zu Ihrem Rasa-Bot-Root und erstellen Sie eine neue Datei docker-compose.yml. Fügen Sie die folgenden Daten in die Datei ein:

version: '3.0'
services:
 rasa:
   image: rasa/rasa:1.10.16-full
   ports:
  - 5005:5005
   volumes:
  - ./:/app
   command:
  - run

Um die in Ihrer docker-compose.yml konfigurierten Dienste zu starten, führen Sie aus:

sudo docker-compose up

Dadurch wird der Docker-Container für Rasa gestartet. Jetzt können Sie Rasa in einem Container ausführen.

Aktion Server

Da wir Aktionen konfiguriert haben, sollten wir auch einen Aktionsserver zur Verfügung haben.

Wir müssen zuerst das Image erstellen und es dann in unserer Docker-Compose-Datei referenzieren. Legen Sie also zunächst im Stammverzeichnis des Bots ein Verzeichnis actions an. Verschieben Sie dann Ihre actions.py-Datei in diesen Ordner. Erstellen Sie im selben Ordner eine init.py-Datei.

Als Nächstes erstellen Sie ein Dockerfile im Stammverzeichnis Ihres Bot-Projekts und fügen Folgendes ein:

# Extend the official Rasa SDK image
FROM rasa/rasa-sdk:1.10.2

# Use subdirectory as the working directory
WORKDIR /app

# Copy any additional custom requirements, if necessary (uncomment next line)
# COPY actions/requirements-actions.txt ./

# Change back to root user to install dependencies
USER root

# Install extra requirements for actions code, if necessary (uncomment next line)
# RUN pip install -r requirements-actions.txt

# Copy actions folder to the working directory
COPY ./actions /app/actions

# By best practices, don't run the code with root user
USER 1001

Als Nächstes müssen Sie einen kostenlosen Docker Account erstellen auf https://www.docker.com. Anschließend erstellen Sie ein Repository, in dem Ihr Image gespeichert wird, ähnlich wie bei Github.

Nachdem Sie Ihr Repository erstellt haben, führen Sie den folgenden Befehl aus und ersetzen Sie ihn durch Ihren Benutzernamen, den Namen des Repositorys und den Namen Ihres Bildes:

docker build . -t <account_username>/<repository_name>:<custom_image_tag>

Wenn dieser Befehl erfolgreich ausgeführt wird, wird Ihr Image in diesem Repository verfügbar sein. Sie können dann zur Datei docker-compose.yml zurückkehren und das Folgende hinzufügen:

app:

image: <image:tag>

expose: 5055

Mit diesem Befehl wird Docker angewiesen, Ihr Aktions-Image auf Port 5055 auszuführen.

Sie können docker-compose up ausführen und sowohl der Rasa HTTP-Server als auch die Aktionen werden mit Docker ausgeführt und Sie können mit ihnen kommunizieren.

Wir haben unser Marketing-Tool mit Hilfe der Vonage API, Django und Rasa NLU erfolgreich erstellt und eingesetzt.