Alisos būsenos įgūdžių sukūrimas naudojant Yandex.Cloud ir Python funkcijas be serverio

Pradėkime nuo naujienų. Vakar „Yandex.Cloud“ paskelbė apie kompiuterių be serverio paslaugos paleidimą „Yandex“ debesies funkcijos. Tai reiškia: jūs rašote tik savo paslaugos kodą (pavyzdžiui, žiniatinklio programai ar pokalbių robotui), o debesis pats sukuria ir prižiūri virtualias mašinas, kuriose veikia, ir netgi atkartoja jas, jei apkrova didėja. Jums visai nereikia galvoti, tai labai patogu. O mokėjimas tik už skaičiavimo laiką.

Tačiau kai kurie gali visai nemokėti. Tai yra kūrėjai Alisos išoriniai įgūdžiai, tai yra, jame įmontuoti pokalbių robotai. Bet kuris kūrėjas gali rašyti, priglobti ir registruoti tokį įgūdį, o nuo šiandien įgūdžių net nebereikia priglobti – tiesiog įkelkite savo kodą į debesį formoje ta pati funkcija be serverio.

Tačiau yra pora niuansų. Pirma, jūsų duobės kodui gali prireikti tam tikrų priklausomybių, o jų vilkimas į debesį yra nereikšmingas. Antra, bet kuris įprastas pokalbių robotas turi kažkur išsaugoti dialogo būseną (taigi, tai reiškia); Koks yra lengviausias būdas tai padaryti naudojant funkciją be serverio? Trečia, kaip galite parašyti greitą ir nešvarų įgūdį Alisai ar net kokį nors robotą, kurio siužetas nėra nulis? Straipsnis iš tikrųjų yra apie šiuos niuansus.

Moralinis pasiruošimas

Nekantriesiems: prieš įkeldamas funkciją į debesį surenku reikiamas priklausomybes su makefile, dialogo lango būseną išsaugau „Yandex Object Storage“ (ji palaiko S3 API), o dialogui tvarkyti naudoju savo biblioteką. tgalice. Galų gale paaiškėja toks demonstracinis įgūdis. Dabar pažvelkime į visa tai šiek tiek išsamiau.

Šiek tiek nekantraujantiems, prieš pasineriant į mano istoriją apie sudėtingumą, labai rekomenduoju pradėti nuo ko nors paprasto. Būtent sukurti vieno failo echobot funkciją, užregistruoti ir išbandyti ją Dialogs kūrėjų pulte; detales - in Dialogų dienoraštis и Debesų dokumentacija. Ir tik tada pradėkite.

Jei norite iš karto pajusti, dėl ko mes čia kovojame, paklauskite Alisos.įgalinti „IT horoskopo“ įgūdžius“. Turėtų įvykti dialogas, panašus į šį:

Alisa: Sveiki! Jūs turite „IT horoskopo“ įgūdžius. Pasakykite „Pradėti“, kad sužinotumėte, ką jums žada žvaigždės.
Vartotojas: Pradėti
A: Nurodykite savo vardą
Yu: Vasisualiy
A: Dabar pasakyk man savo gimimo metus. Tik keturi skaitmenys, nieko papildomo.
Yu: antra
A: Bandykite dar kartą. Įveskite savo gimimo metus – keturi skaitmenys.
Yu: 2002 m
Puikus! Dabar pavadinkite savo gimimo mėnesį.
Yu: Vasaris
Puikus! Galiausiai pasakykite savo gimimo datą – tik skaičių, tik vieną ar du skaitmenis.
Yu: 18 m
A: Ačiū, Vasisualiy! Dabar mes žinome: jums 17 metų ir esate Vandenis. Na, žinoma, tau pasisekė! Žvaigždės tau sako: а что говорят звёзды, вы узнаете, запустив навык.

Bėda ta, kad norint palaikyti net tokį paprastą dialogą, reikia atsiminti vartotojo vardą ir gimimo datą, o be serverio funkcijų aplinkoje tai nėra trivialu. Nebus įmanoma išsaugoti konteksto RAM arba kaip failo diske, nes „Yandex.Cloud“ vienu metu gali paleisti funkciją keliose virtualiose mašinose ir savo nuožiūra perjungti tarp jų. Turėsite naudoti tam tikrą išorinę saugyklą. „Object Storage“ buvo pasirinkta kaip gana nebrangi ir nesudėtinga saugykla tiesiai „Yandex.Cloud“ (t. y. greičiausiai greita). Kaip nemokamą alternatyvą galite išbandyti, pavyzdžiui, nemokamą kūrinį Debesuota Monga kažkur toli. Yra patogūs Python paketai, skirti tiek objektų saugyklai (kuri palaiko S3 sąsają), tiek Mongo.

Kita problema yra ta, kad norint pasiekti objektų saugyklą, MongoDB ir bet kurią kitą duomenų bazę ar duomenų saugyklą, reikia tam tikrų išorinių priklausomybių, kurias reikia įkelti į „Yandex Functions“ kartu su funkcijos kodu. Ir aš norėčiau tai padaryti patogiai. Deja, tai nebus visiškai patogu (kaip Heroku), bet kai kuriuos pagrindinius patogumus galima sukurti parašant scenarijų aplinkai sukurti (padaryti failą).

Kaip paleisti horoskopo įgūdžius

1. Pasiruoškite: pereikite prie kompiuterio su Linux. Iš principo tikriausiai galite dirbti ir su „Windows“, bet tada turėsite atlikti šiek tiek magijos paleisdami makefile. Ir bet kuriuo atveju jums reikės įdiegti bent „Python 3.6“.
2. Klonuokite jį iš Github horoskopo įgūdžių pavyzdys.
3. Registruotis Y.Cloud: https://cloud.yandex.ru
4. Susikurkite sau du kibirus Objektų saugykla, vadink juos bet kokiu vardu {BUCKET NAME} и tgalice-test-cold-storage (šis antrasis pavadinimas dabar užkoduotas main.py mano pavyzdys). Pirmasis segmentas bus reikalingas tik diegimui, antrasis - dialogo būsenoms saugoti.
5. kurti paslaugų sąskaita, suteik jam vaidmenį editor, ir gaukite statinius kredencialus {KEY ID} и {KEY VALUE} — panaudosime juos dialogo būsenai įrašyti. Visa tai reikalinga tam, kad Ya.Cloud funkcija galėtų pasiekti saugyklą iš Ya.Cloud. Tikiuosi, kad kada nors autorizacija taps automatizuota, bet kol kas taip.
6. (Neprivaloma) įdiegti komandinės eilutės sąsaja yc. Taip pat galite sukurti funkciją per žiniatinklio sąsają, tačiau CLI yra geras, nes joje greičiau atsiranda visokių naujovių.
7. Dabar iš tikrųjų galite paruošti priklausomybės rinkinį: paleiskite komandų eilutę aplanke su įgūdžių pavyzdžiu make all. Aplanke bus įdiegta krūva bibliotekų (dažniausiai, kaip įprasta, nereikalingos). dist.
8. Supilkite į objektų saugyklą rankomis (į kibirą {BUCKET NAME}) archyvas, gautas atliekant ankstesnį veiksmą dist.zip. Jei norite, galite tai padaryti iš komandinės eilutės, pavyzdžiui, naudodami AWS CLI.
9. Sukurkite be serverio funkciją naudodami žiniatinklio sąsają arba naudodami programą yc. Naudingumui komanda atrodys taip:

yc serverless function version create
    --function-name=horoscope
    --environment=AWS_ACCESS_KEY_ID={KEY ID},AWS_SECRET_ACCESS_KEY={KEY VALUE}
    --runtime=python37
    --package-bucket-name={BUCKET NAME}
    --package-object-name=dist.zip
    --entrypoint=main.alice_handler
    --memory=128M
    --execution-timeout=3s

Kuriant funkciją rankiniu būdu, visi parametrai pildomi vienodai.

Dabar sukurtą funkciją galima išbandyti kūrėjo pulte, o tada patobulinti ir paskelbti įgūdžius.

Kas yra po gaubtu

Makefile iš tikrųjų yra gana paprastas scenarijus, skirtas įdiegti priklausomybes ir įdėti jas į archyvą dist.zip, maždaug taip:

mkdir -p dist/
pip3 install -r requirements.txt --target dist/ 
cp main.py dist/main.py
cp form.yaml dist/form.yaml
cd dist && zip --exclude '*.pyc' -r ../dist.zip ./*

Likusi dalis yra keletas paprastų įrankių, supakuotų į biblioteką tgalice. Vartotojo duomenų pildymo procesą aprašo konfigūracija form.yaml:

form_name: 'horoscope_form'
start:
  regexp: 'старт|нач(ать|ни)'
  suggests:
    - Старт
fields:
  - name: 'name'
    question: Пожалуйста, назовите своё имя.
  - name: 'year'
    question: Теперь скажите мне год вашего рождения. Только четыре цифры, ничего лишнего.
    validate_regexp: '^[0-9]{4}$'
    validate_message: Пожалуйста, попробуйте ещё раз. Назовите год вашего рождения - четыре цифры.
  - name: 'month'
    question: Замечательно! Теперь назовите месяц вашего рождения.
    options:
      - январь
     ...
      - декабрь
    validate_message: То, что вы назвали, не похоже на месяц. Пожалуйста, назовите месяц вашего рождения, без других слов.
  - name: 'day'
    question: Отлично! Наконец, назовите мне дату вашего рождения - только число, всего одна или две цифры.
    validate_regexp: '[0123]?d$'
    validate_message: Пожалуйста, попробуйте ещё раз. Вам нужно назвать число своего рождения (например, двадцатое); это одна или две цифры.

Šios konfigūracijos analizavimo ir galutinio rezultato apskaičiavimo darbus perima Python klasė

class CheckableFormFiller(tgalice.dialog_manager.form_filling.FormFillingDialogManager):
    SIGNS = {
        'январь': 'Козерог',
        ...
    }

    def handle_completed_form(self, form, user_object, ctx):
        response = tgalice.dialog_manager.base.Response(
            text='Спасибо, {}! Теперь мы знаем: вам {} лет, и вы {}. n'
                 'Вот это вам, конечно, повезло! Звёзды говорят вам: {}'.format(
                form['fields']['name'],
                2019 - int(form['fields']['year']),
                self.SIGNS[form['fields']['month']],
                random.choice(FORECASTS),
            ),
            user_object=user_object,
        )
        return response

Tiksliau, bazinė klasė FormFillingDialogManager susijęs su „formos“ užpildymu ir vaikų klasės metodu handle_completed_form pasako jai, ką daryti, kai ji bus pasiruošusi.

Be šio pagrindinio dialogo srauto, vartotojas taip pat turi būti pasveikintas, taip pat jam turi būti suteikta pagalba naudojant „help“ komandą ir atleidžiama nuo įgūdžių naudojant komandą „exit“. Šiuo tikslu į tgalice Taip pat yra šablonas, todėl visa dialogo tvarkyklė susideda iš dalių:

dm = tgalice.dialog_manager.CascadeDialogManager(
    tgalice.dialog_manager.GreetAndHelpDialogManager(
        greeting_message=DEFAULT_MESSAGE,
        help_message=DEFAULT_MESSAGE,
        exit_message='До свидания, приходите в навык "Айтишный гороскоп" ещё!'
    ),
    CheckableFormFiller(`form.yaml`, default_message=DEFAULT_MESSAGE)
)

CascadeDialogManager Tai veikia paprastai: paeiliui bando visus savo komponentus pritaikyti esamai dialogo būsenai ir pasirenka pirmąjį tinkamą.

Dialogo tvarkyklė pateikia Python objektą kaip atsakymą į kiekvieną pranešimą. Response, kurį vėliau galima konvertuoti į paprastą tekstą arba į pranešimą Alice arba Telegram – priklausomai nuo to, kur veikia robotas; jame taip pat yra pakeista dialogo būsena, kurią reikia išsaugoti. Visą šią virtuvę tvarko kita klasė, DialogConnector, todėl tiesioginis „Yandex Functions“ įgūdžių paleidimo scenarijus atrodo taip:

...
session = boto3.session.Session()
s3 = session.client(
    service_name='s3',
    endpoint_url='https://storage.yandexcloud.net',
    aws_access_key_id=os.environ['AWS_ACCESS_KEY_ID'],
    aws_secret_access_key=os.environ['AWS_SECRET_ACCESS_KEY'],
    region_name='ru-central1',
)
storage = tgalice.session_storage.S3BasedStorage(s3_client=s3, bucket_name='tgalice-test-cold-storage')
connector = tgalice.dialog_connector.DialogConnector(dialog_manager=dm, storage=storage)
alice_handler = connector.serverless_alice_handler

Kaip matote, didžioji šio kodo dalis sukuria ryšį su objektų saugyklos S3 sąsaja. Galite perskaityti, kaip šis ryšys naudojamas tiesiogiai tgalice kode.
Paskutinė eilutė sukuria funkciją alice_handler — tą patį, kurį liepėme „Yandex.Cloud“ ištraukti, kai nustatome parametrą --entrypoint=main.alice_handler.

Tai viskas, iš tikrųjų. Makefiles surinkimui, S3 tipo objektų saugykla kontekstui saugoti ir Python biblioteka tgalice. Kartu su Python funkcijomis be serverių ir išraiškingumu to pakanka sveikam žmogaus įgūdžiui išsiugdyti.

Galite paklausti, kodėl reikėjo kurti tgalice? Jame yra visas nuobodus kodas, perkeliantis JSON iš užklausos į atsakymą ir iš saugyklos į atmintį ir atgal. Taip pat yra įprasta kodo programa, funkcija, skirta suprasti, kad „vasaris“ yra panašus į „vasarį“, ir kiti NLU, skirti vargšams. Pagal mano idėją, to jau turėtų pakakti, kad galėtumėte nubrėžti įgūdžių prototipus yaml failuose, pernelyg nesiblaškydami dėl techninių detalių.

Jei norite rimtesnio NLU, galite tai pridėti prie savo įgūdžių Skonis arba Gilus Pavlovas, tačiau norint juos nustatyti, reikės papildomų šokių su tamburinu, ypač naudojant be serverio. Jei visai nenorite koduoti, turėtumėte naudoti vizualinį konstruktorių Aimylogic. Kurdamas tgalicę galvojau apie kažkokį tarpinį kelią. Pažiūrėkime, kas iš to išeis.

Na, dabar prisijunk Alice įgūdžių kūrėjo pokalbis, skaitykite dokumentacija, ir sukurti nuostabų įgūdžių!

Šaltinis: www.habr.com