Hallo habrozhiteli! Dieses Noah-Geschenkbuch richtet sich an alle, die sich für KI, maschinelles Lernen, Cloud Computing und eine beliebige Kombination von Datenthemen interessieren. Sowohl Programmierer als auch einfach fürsorgliche Technikfreaks finden hier nützliche Informationen. Codebeispiele finden Sie in Python. Es behandelt viele fortgeschrittene Themen wie die Verwendung von Cloud-Plattformen (wie AWS, GCP und Azure) sowie Techniken des maschinellen Lernens und die Implementierung von KI. Jedi, die Python, Cloud Computing und ML fließend beherrschen, finden auch viele nützliche Ideen für sich, die sie sofort in ihrer aktuellen Arbeit anwenden können.
Wir laden Sie ein, einen Auszug aus dem Buch "Erstellen eines intelligenten Slack-Bots in AWS" zu lesen.
Die Menschen haben lange davon geträumt, ein „künstliches Leben“ zu schaffen. Meistens ist dies durch das Erstellen von Bots möglich. Bots werden zu einem immer wichtigeren Bestandteil unseres täglichen Lebens, insbesondere seit dem Aufkommen von Siri von Apple und Alexa von Amazon. In diesem Kapitel werden wir alle Geheimnisse der Erstellung von Bots enthüllen.
Bot-Erstellung
Um den Bot zu erstellen, verwenden wir die Slack-Bibliothek für die Python-Sprache (https://github.com/slackapi/python-slackclient). Um mit Slack zu beginnen, müssen Sie ein Identifikationstoken generieren. Im Allgemeinen ist es sinnvoll, mit solchen Markern eine Umgebungsvariable zu exportieren. Ich mache das oft in virtualenv und erhalte so automatisch Zugriff darauf, wenn es in der aktuellen Umgebung ausgeführt wird. Dazu müssen Sie das Dienstprogramm virtualenv ein wenig „knacken“, indem Sie das Aktivierungsskript bearbeiten.
Wenn Sie die Variable Slack in das Skript ~ / .env / bin / enable exportieren, sieht sie wie folgt aus.
Und nur zur Information, wenn Sie mit den neuesten Innovationen Schritt halten möchten, wird empfohlen, das neue offizielle Python-Dienstprogramm zum Verwalten der Umgebung zu verwenden - pipenv (https://github.com/pypa/pipenv):
_OLD_VIRTUAL_PATH="$PATH" PATH="$VIRTUAL_ENV/bin:$PATH" export PATH SLACK_API_TOKEN=<Your Token Here> export SLACK_API_TOKEN
Es ist praktisch, mit dem Befehl printenv der Betriebssysteme OS X und Linux zu überprüfen, ob die Umgebungsvariable festgelegt ist. Danach können Sie das folgende kurze Skript verwenden, um das Senden einer Nachricht zu überprüfen:
import os from slackclient import SlackClient slack_token = os.environ["SLACK_API_TOKEN"] sc = SlackClient(slack_token) sc.api_call( "chat.postMessage", channel="#general", text="Hello from my bot! :tada:" )
Es ist auch erwähnenswert, dass das Dienstprogramm pipenv die empfohlene Lösung ist, die die Funktionen der Dienstprogramme pip und virtualenv in einer Komponente kombiniert. Es ist zu einem neuen Standard geworden, daher ist es sinnvoll, ihn unter dem Gesichtspunkt der Paketverwaltung zu betrachten.
Konvertieren Sie die Bibliothek in das Befehlszeilenprogramm
Wie bei den anderen Beispielen in diesem Buch ist es eine gute Idee, unseren Code in ein Befehlszeilenprogramm zu konvertieren, um das Testen neuer Ideen zu vereinfachen. Es ist erwähnenswert, dass viele unerfahrene Entwickler oft keine Befehlszeilentools bevorzugen, sondern andere Lösungen, zum Beispiel, einfach in Jupiter-Notebooks arbeiten. Ich werde für kurze Zeit die Rolle des Anwalts des Teufels spielen und eine Frage stellen, die die Leser möglicherweise haben: „Warum brauchen wir Befehlszeilenprogramme in einem Projekt, das auf Jupiter-Notizbüchern basiert? Ist es nicht der Sinn von Jupiter-Notizblöcken, die Befehlsshell und die Befehlszeile unnötig zu machen? " Das Hinzufügen eines Befehlszeilenprogramms zu einem Projekt ist gut, da Sie damit schnell verschiedene Eingabeoptionen ausprobieren können. Jupiter-Notebook-Codeblöcke akzeptieren keine Eingaben. In gewissem Sinne handelt es sich dabei um Skripte mit fest verdrahteten Daten.
Viele Befehlszeilenprogramme auf GCP- und AWS-Plattformen sind nicht zufällig vorhanden: Sie bieten Flexibilität und Funktionen, die auf grafischen Oberflächen nicht verfügbar sind. Eine wunderbare Sammlung von Aufsätzen zu diesem Thema des Science-Fiction-Schriftstellers Neal Stephenson heißt „Am Anfang ... gab es eine Befehlszeile“. Darin sagt Stevenson: "GUIs verursachen einen erheblichen zusätzlichen Aufwand für jede, selbst die kleinste Softwarekomponente, die die Programmierumgebung vollständig verändert." Er beendet die Sammlung mit den Worten: „... das Leben ist eine sehr schwierige und schwierige Sache; Keine Schnittstelle wird das ändern. und jeder, der anders denkt, ist ein Simpleton ... "Hart genug, aber meine Erfahrung zeigt, dass es wahr genug ist. Das Leben mit der Kommandozeile wird besser. Probieren Sie es aus und Sie möchten nicht zur GUI zurückkehren.
Dazu verwenden wir das unten gezeigte Klickpaket. Das Senden von Nachrichten über die neue Benutzeroberfläche ist sehr einfach.
./clibot.py send --message "from cli" sending message from cli to #general
Abbildung 7.1 zeigt die Standardwerte sowie die benutzerdefinierte Nachricht des Dienstprogramms cli.
#!/usr/bin/env python import os import click from slackclient import SlackClient SLACK_TOKEN = os.environ["SLACK_API_TOKEN"] def send_message(channel="#general", message="Hello from my bot!"): """ """ slack_client = SlackClient(SLACK_TOKEN) res = slack_client.api_call( "chat.postMessage", channel=channel, text=message ) return res @click.group() @click.version_option("0.1") def cli(): """ """ @cli.command("send") @click.option("--message", default="Hello from my bot!", help="text of message") @click.option("--channel", default="#general", help="general channel") def send(channel, message): click.echo(f"sending message {message} to {channel}") send_message(channel, message=message) if __name__ == '__main__': cli()
Mit dem AWS Step Functions-Service bringen wir den Bot auf eine neue Ebene
Nachdem Sie Kommunikationskanäle zum Senden von Nachrichten an Slack erstellt haben, können Sie unseren Code verbessern: Führen Sie ihn nach einem Zeitplan aus und verwenden Sie ihn für nützliche Aktionen. Der AWS Step Functions Service ist dafür hervorragend geeignet. Im nächsten Abschnitt wird unser Slack-Bot lernen, die Sportseiten von Yahoo! NBA-Spieler rufen ihren Geburtsort ab und senden diese Daten an Slack.
Abbildung 7.2 zeigt eine vorgefertigte Schritt-für-Schritt-Funktion in Aktion. Der erste Schritt besteht darin, die URLs des NBA-Spielerprofils zu extrahieren, und der zweite darin, die Beautiful Soup-Bibliothek zu verwenden, um den Geburtsort jedes Spielers zu finden. Nach Abschluss der Schritt-für-Schritt-Funktion werden die Ergebnisse an Slack zurückgesendet.
AWS Lambda und Chalice können verwendet werden, um die einzelnen Teile der Arbeit innerhalb einer Schrittfunktion zu koordinieren. Mit Lambda (https://aws.amazon.com/lambda/) kann der Benutzer Funktionen in AWS ausführen, und mit dem Chalice-Framework (http://chalice.readthedocs.io/en/latest/) können Sie serverlose Anwendungen in Python erstellen. Hier sind einige Voraussetzungen:
- Der Benutzer muss über ein AWS-Konto verfügen.
- Der Benutzer benötigt Anmeldeinformationen, um die API verwenden zu können.
- Die Lambda-Rolle (von Chalice erstellt) muss über eine Richtlinie mit den Berechtigungen verfügen, die zum Aufrufen der entsprechenden AWS-Services erforderlich sind, z. B. S3.
Konfigurieren Sie die IAM-Anmeldeinformationen
Detaillierte Anweisungen zum Einrichten von AWS-Anmeldeinformationen finden Sie unter
boto3.readthedocs.io/en/latest/guide/configuration.html . Informationen zum Exportieren von AWS-Variablen unter Windows- und Linux-Betriebssystemen
finden Sie hier . Es gibt viele Möglichkeiten, Anmeldeinformationen zu konfigurieren, aber Benutzer von virtualenv können AWS-Anmeldeinformationen in einer lokalen virtuellen Umgebung im Skript / bin / enabled ablegen:
# AWS AWS_DEFAULT_REGION=us-east-1 AWS_ACCESS_KEY_ID=xxxxxxxx AWS_SESSION_TOKEN=xxxxxxxx
# export AWS_DEFAULT_REGION export AWS_ACCESS_KEY_ID export AWS_DEFAULT_REGION
Arbeite mit Kelch. Chalice verfügt über ein Befehlszeilenprogramm mit vielen verfügbaren Befehlen:
Usage: chalice [OPTIONS] COMMAND [ARGS]... Options: --version Show the version and exit. --project-dir TEXT The project directory. Defaults to CWD --debug / --no-debug Print debug logs to stderr. --help Show this message and exit. Commands: delete deploy gen-policy generate-pipeline Generate a cloudformation template for a... generate-sdk local logs new-project package url
Der Code in der Vorlage app.py kann durch die Funktionen des Lambda-Dienstes ersetzt werden. AWS Chalice ist insofern praktisch, als es die Möglichkeit bietet, zusätzlich zu Webdiensten eigenständige Lambda-Funktionen zu erstellen. Dank dieser Funktionalität können Sie mehrere Lambda-Funktionen erstellen, sie einer schrittweisen Funktion zuordnen und sie wie Lego-Würfel zusammenführen.
Sie können beispielsweise einfach eine geplante Lambda-Funktion erstellen, die eine beliebige Aktion ausführt:
@app.schedule(Rate(1, unit=Rate.MINUTES)) def every_minute(event): """, """ # Slack
Um die Interaktion mit dem Bot für das Web-Scraping herzustellen, müssen Sie mehrere Funktionen erstellen. Am Anfang der Datei gibt es Importe und eine Reihe von Variablen werden deklariert:
import logging import csv from io import StringIO import boto3 from bs4 import BeautifulSoup import requests from chalice import (Chalice, Rate) APP_NAME = 'scrape-yahoo' app = Chalice(app_name=APP_NAME) app.log.setLevel(logging.DEBUG)
Der Bot muss möglicherweise einige der Daten in S3 speichern. Die folgende Funktion verwendet Boto, um die Ergebnisse in einer CSV-Datei zu speichern:
def create_s3_file(data, name="birthplaces.csv"): csv_buffer = StringIO() app.log.info(f"Creating file with {data} for name") writer = csv.writer(csv_buffer) for key, value in data.items(): writer.writerow([key,value]) s3 = boto3.resource('s3') res = s3.Bucket('aiwebscraping').\ put_object(Key=name, Body=csv_buffer.getvalue()) return res
Die Funktion fetch_page verwendet
die Beautiful Soup-Bibliothek , um eine HTML-Seite zu analysieren, die sich gemäß der NBA-Statistik-URL befindet, und gibt ein Suppenobjekt zurück:
def fetch_page(url="https://sports.yahoo.com/nba/stats/"): """ URL Yahoo""" # # Beautiful Soup app.log.info(f"Fetching urls from {url}") res = requests.get(url) soup = BeautifulSoup(res.content, 'html.parser') return soup
Die Funktionen get_player_links und fetch_player_urls erhalten Links zu URLs des Spielerprofils:
def get_player_links(soup): """ URL URL 'a' 'nba/players' """ nba_player_urls = [] for link in soup.find_all('a'): link_url = link.get('href') # if link_url: if "nba/players" in link_url: print(link_url) nba_player_urls.append(link_url) return nba_player_urls def fetch_player_urls(): """ URL """ soup = fetch_page() urls = get_player_links(soup) return urls
Als Nächstes rufen wir in der Funktion find_birthplaces den Geburtsort des Players von den Seiten ab, die sich unter diesen URLs befinden:
def find_birthplaces(urls): """ NBA Yahoo""" birthplaces = {} for url in urls: profile = requests.get(url) profile_url = BeautifulSoup(profile.content, 'html.parser') lines = profile_url.text res2 = lines.split(",") key_line = [] for line in res2: if "Birth" in line: #print(line) key_line.append(line) try: birth_place = key_line[0].split(":")[-1].strip() app.log.info(f"birth_place: {birth_place}") except IndexError: app.log.info(f"skipping {url}") continue birthplaces[url] = birth_place app.log.info(birth_place) return birthplaces
Nun kommen wir zu den Funktionen von Kelch. Bitte beachten Sie: Für das Chalice-Framework muss der Standardpfad erstellt werden:
# HTTP- @app.route('/') def index(): """ URL""" app.log.info(f"/ Route: for {APP_NAME}") return {'app_name': APP_NAME}
Die folgende Lambda-Funktion ist eine Route, die eine HTTP-URL mit einer zuvor geschriebenen Funktion verbindet:
@app.route('/player_urls') def player_urls(): """ URL """ app.log.info(f"/player_urls Route: for {APP_NAME}") urls = fetch_player_urls() return {"nba_player_urls": urls}
Die folgenden Lambda-Funktionen sind eigenständig und können innerhalb einer Schritt-für-Schritt-Funktion aufgerufen werden:
# Lambda @app.lambda_function() def return_player_urls(event, context): """ Lambda, URL """ app.log.info(f"standalone lambda 'return_players_urls'\ {APP_NAME} with {event} and {context}") urls = fetch_player_urls() return {"urls": urls} # Lambda @app.lambda_function() def birthplace_from_urls(event, context): """ """ app.log.info(f"standalone lambda 'birthplace_from_urls'\ {APP_NAME} with {event} and {context}") payload = event["urls"] birthplaces = find_birthplaces(payload) return birthplaces # Lambda @app.lambda_function() def create_s3_file_from_json(event, context): """ S3 JSON""" app.log.info(f"Creating s3 file with event data {event}\ and context {context}") print(type(event)) res = create_s3_file(data=event) app.log.info(f"response of putting file: {res}") return True
Wenn Sie die resultierende Chalice-Anwendung lokal ausführen, werden die folgenden Ergebnisse angezeigt:
→ scrape-yahoo git:(master) chalice local Serving on 127.0.0.1:8000 scrape-yahoo - INFO - / Route: for scrape-yahoo 127.0.0.1 - - [12/Dec/2017 03:25:42] "GET / HTTP/1.1" 200 - 127.0.0.1 - - [12/Dec/2017 03:25:42] "GET /favicon.ico" scrape-yahoo - INFO - / Route: for scrape-yahoo 127.0.0.1 - - [12/Dec/2017 03:25:45] "GET / HTTP/1.1" 200 - 127.0.0.1 - - [12/Dec/2017 03:25:45] "GET /favicon.ico" scrape-yahoo - INFO - /player_urls Route: for scrape-yahoo scrape-yahoo - INFO - https://sports.yahoo.com/nba/stats/ https://sports.yahoo.com/nba/players/4563/ https://sports.yahoo.com/nba/players/5185/ https://sports.yahoo.com/nba/players/3704/ https://sports.yahoo.com/nba/players/5012/ https://sports.yahoo.com/nba/players/4612/ https://sports.yahoo.com/nba/players/5015/ https://sports.yahoo.com/nba/players/4497/ https://sports.yahoo.com/nba/players/4720/ https://sports.yahoo.com/nba/players/3818/ https://sports.yahoo.com/nba/players/5432/ https://sports.yahoo.com/nba/players/5471/ https://sports.yahoo.com/nba/players/4244/ https://sports.yahoo.com/nba/players/5464/ https://sports.yahoo.com/nba/players/5294/ https://sports.yahoo.com/nba/players/5336/ https://sports.yahoo.com/nba/players/4390/ https://sports.yahoo.com/nba/players/4563/ https://sports.yahoo.com/nba/players/3704/ https://sports.yahoo.com/nba/players/5600/ https://sports.yahoo.com/nba/players/4624/ 127.0.0.1 - - [12/Dec/2017 03:25:53] "GET /player_urls" 127.0.0.1 - - [12/Dec/2017 03:25:53] "GET /favicon.ico"
Führen Sie zum Bereitstellen der Anwendung den Befehl chalice deploy aus:
→ scrape-yahoo git:(master) chalice deploy Creating role: scrape-yahoo-dev Creating deployment package. Creating lambda function: scrape-yahoo-dev Initiating first time deployment. Deploying to API Gateway stage: api https://bt98uzs1cc.execute-api.us-east-1.amazonaws.com/api/
Dank der Befehlszeilenschnittstelle für HTTP (https://github.com/jakubroztocil/httpie) rufen wir die HTTP-Route von AWS auf und extrahieren die in / api / player_urls verfügbaren Links:
→ scrape-yahoo git:(master) http \ https://<a lambda route>.amazonaws.com/api/player_urls HTTP/1.1 200 OK Connection: keep-alive Content-Length: 941 Content-Type: application/json Date: Tue, 12 Dec 2017 11:48:41 GMT Via: 1.1 ba90f9bd20de9ac04075a8309c165ab1.cloudfront.net (CloudFront) X-Amz-Cf-Id: ViZswjo4UeHYwrc9e-5vMVTDhV_Ic0dhVIG0BrDdtYqd5KWcAuZKKQ== X-Amzn-Trace-Id: sampled=0;root=1-5a2fc217-07cc12d50a4d38a59a688f5c X-Cache: Miss from cloudfront x-amzn-RequestId: 64f24fcd-df32-11e7-a81a-2b511652b4f6 { "nba_player_urls": [ "https://sports.yahoo.com/nba/players/4563/", "https://sports.yahoo.com/nba/players/5185/", "https://sports.yahoo.com/nba/players/3704/", "https://sports.yahoo.com/nba/players/5012/", "https://sports.yahoo.com/nba/players/4612/", "https://sports.yahoo.com/nba/players/5015/", "https://sports.yahoo.com/nba/players/4497/", "https://sports.yahoo.com/nba/players/4720/", "https://sports.yahoo.com/nba/players/3818/", "https://sports.yahoo.com/nba/players/5432/", "https://sports.yahoo.com/nba/players/5471/", "https://sports.yahoo.com/nba/players/4244/", "https://sports.yahoo.com/nba/players/5464/", "https://sports.yahoo.com/nba/players/5294/", "https://sports.yahoo.com/nba/players/5336/", "https://sports.yahoo.com/nba/players/4390/", "https://sports.yahoo.com/nba/players/4563/", "https://sports.yahoo.com/nba/players/3704/", "https://sports.yahoo.com/nba/players/5600/", "https://sports.yahoo.com/nba/players/4624/" ] }
Eine weitere bequeme Möglichkeit, mit Lambda-Funktionen zu arbeiten, besteht darin, sie direkt über das Click-Paket und die Python Boto-Bibliothek aufzurufen.
Wir können ein neues Befehlszeilenprogramm namens wscli.py erstellen (kurz für Web-Scraping-Befehlszeilenschnittstelle - „Befehlszeilenschnittstelle für Web-Scraping“). Im ersten Teil des Codes konfigurieren wir die Protokollierung und importieren die Bibliotheken:
#!/usr/bin/env python import logging import json import boto3 import click from pythonjsonlogger import jsonlogger # log = logging.getLogger(__name__) log.setLevel(logging.INFO) LOGHANDLER = logging.StreamHandler() FORMMATTER = jsonlogger.JsonFormatter() LOGHANDLER.setFormatter(FORMMATTER) log.addHandler(LOGHANDLER)
Die folgenden drei Funktionen dienen zur Verbindung mit der Lambda-Funktion über invoke_lambda:
### API Boto Lambda def lambda_connection(region_name="us-east-1"): """ Lambda""" lambda_conn = boto3.client("lambda", region_name=region_name) extra_msg = {"region_name": region_name, "aws_service": "lambda"} log.info("instantiate lambda client", extra=extra_msg) return lambda_conn def parse_lambda_result(response): """ Boto JSON""" body = response['Payload'] json_result = body.read() lambda_return_value = json.loads(json_result) return lambda_return_value def invoke_lambda(func_name, lambda_conn, payload=None, invocation_type="RequestResponse"): """ Lambda""" extra_msg = {"function_name": func_name, "aws_service": "lambda", "payload":payload} log.info("Calling lambda function", extra=extra_msg) if not payload: payload = json.dumps({"payload":"None"}) response = lambda_conn.invoke(FunctionName=func_name, InvocationType=invocation_type, Payload=payload ) log.info(response, extra=extra_msg) lambda_return_value = parse_lambda_result(response) return lambda_return_value
Wir verpacken die Funktion invoke_lambda mit dem Python-Paket, um Click-Befehlszeilenprogramme zu erstellen. Bitte beachten Sie, dass wir den Standardwert für die Option --func festlegen, die die zuvor bereitgestellte Lambda-Funktion verwendet:
@click.group() @click.version_option("1.0") def cli(): """ -""" @cli.command("lambda") @click.option("--func", default="scrape-yahoo-dev-return_player_urls", help="name of execution") @click.option("--payload", default='{"cli":"invoke"}', help="name of payload") def call_lambda(func, payload): """ Lambda ./wscli.py lambda """ click.echo(click.style("Lambda Function invoked from cli:", bg='blue', fg='white')) conn = lambda_connection() lambda_return_value = invoke_lambda(func_name=func, lambda_conn=conn, payload=payload) formatted_json = json.dumps(lambda_return_value, sort_keys=True, indent=4) click.echo(click.style( "Lambda Return Value Below:", bg='blue', fg='white')) click.echo(click.style(formatted_json,fg="red")) if __name__ == "__main__": cli()
Die von diesem Dienstprogramm angezeigten Ergebnisse ähneln dem Aufrufen der HTTP-Schnittstelle:
→ X ./wscli.py lambda \ --func=scrape-yahoo-dev-birthplace_from_urls\ --payload '{"url":["https://sports.yahoo.com/nba/players/4624/",\ "https://sports.yahoo.com/nba/players/5185/"]}' Lambda Function invoked from cli: {"message": "instantiate lambda client", "region_name": "us-east-1", "aws_service": "lambda"} {"message": "Calling lambda function", "function_name": "scrape-yahoo-dev-birthplace_from_urls", "aws_service": "lambda", "payload": "{\"url\":[\"https://sports.yahoo.com/nba/players/4624/\", \"https://sports.yahoo.com/nba/players/5185/\"]}"} {"message": null, "ResponseMetadata": {"RequestId": "a6049115-df59-11e7-935d-bb1de9c0649d", "HTTPStatusCode": 200, "HTTPHeaders": {"date": "Tue, 12 Dec 2017 16:29:43 GMT", "content-type": "application/json", "content-length": "118", "connection": "keep-alive", "x-amzn-requestid": "a6049115-df59-11e7-935d-bb1de9c0649d", "x-amzn-remapped-content-length": "0", "x-amz-executed-version": "$LATEST", "x-amzn-trace-id": "root=1-5a3003f2-2583679b2456022568ed0682;sampled=0"}, "RetryAttempts": 0}, "StatusCode": 200, "ExecutedVersion": "$LATEST", "Payload": "<botocore.response.StreamingBody object at 0x10ee37dd8>", "function_name": "scrape-yahoo-dev-birthplace_from_urls", "aws_service": "lambda", "payload": "{\"url\":[\"https://sports.yahoo.com/nba/players/4624/\", \"https://sports.yahoo.com/nba/players/5185/\"]}"} Lambda Return Value Below: { "https://sports.yahoo.com/nba/players/4624/": "Indianapolis", "https://sports.yahoo.com/nba/players/5185/": "Athens" }
Beenden Sie die Erstellung einer Schritt-für-Schritt-Funktion
Der letzte Schritt beim Erstellen einer schrittweisen Funktion, wie in der AWS-Dokumentation (https://docs.aws.amazon.com/step-functions/latest/dg/tutorial-creating-activity-state-machine.html) beschrieben, ist das Erstellen mit Webschnittstelle der Zustandsmaschinenstruktur im JSON-Format (JavaScript Object Notation). Der folgende Code demonstriert diese Pipeline, beginnend mit den ursprünglichen Lambda-Funktionen zum Scrapen von Yahoo!, Speichern von Daten in einer S3-Datei und schließlich zum Senden von Inhalten an Slack:
{ "Comment": "Fetch Player Urls", "StartAt": "FetchUrls", "States": { "FetchUrls": { "Type": "Task", "Resource": \ "arn:aws:lambda:us-east-1:561744971673:\ function:scrape-yahoo-dev-return_player_urls", "Next": "FetchBirthplaces" }, "FetchBirthplaces": { "Type": "Task", "Resource": \ "arn:aws:lambda:us-east-1:561744971673:\ function:scrape-yahoo-dev-birthplace_from_urls", "Next": "WriteToS3" }, "WriteToS3": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:\ 561744971673:function:scrape-yahoo-dev-create_s3_file_from_json", "Next": "SendToSlack" }, "SendToSlack": { "Type": "Task", "Resource": "arn:aws:lambda:us-east-1:561744971673:\ function:send_message", "Next": "Finish" }, "Finish": { "Type": "Pass", "Result": "Finished", "End": true } } }
In Abb. 7.2 Die Ausführung des ersten Teils dieser Pipeline wurde gezeigt. Es ist äußerst nützlich, die Zwischenergebnisse der Zustandsmaschine zu sehen. Darüber hinaus ist die Möglichkeit der Echtzeitüberwachung jedes Teils der Zustandsmaschine zum Debuggen sehr praktisch.
Abbildung 7.3 zeigt eine vollständige Pipeline mit den Schritten zum Schreiben in eine S3-Datei und zum Senden von Inhalten an Slack. Es bleibt nur zu entscheiden, wie dieses Scraping-Dienstprogramm ausgeführt werden soll - in einem bestimmten Zeitintervall oder als Reaktion auf ein Ereignis.
Zusammenfassung
In diesem Kapitel wurden Ihnen viele erstaunliche Konzepte zum Erstellen von KI-Anwendungen vorgestellt. Es wurden das Dienstprogramm Slack Bot und Web Scraping erstellt, die dann mithilfe von serverlosen Diensten von AWS verbunden wurden. Sie können einem solchen anfänglichen Framework noch viel mehr hinzufügen - zum Beispiel die Lambda-Funktion zum Verarbeiten von in natürlichen Sprachen geschriebenen Texten zum Lesen von Webseiten und zum Abrufen ihrer kurzen Inhalte oder den Clustering-Algorithmus ohne Lehrer, der neue NBA-Spieler nach beliebigen Attributen gruppieren würde.
»Weitere Informationen zum Buch finden Sie auf
der Website des Herausgebers»
Inhalt»
Auszug20% Rabatt auf Gutschein für Kuriere -
GeschenkPS: 7% der Kosten des Buches fließen in die Übersetzung neuer Computerbücher. Die Liste der Bücher, die der Druckerei übergeben wurden, finden Sie
hier .