Yandex.Cloud અને Python ના સર્વરલેસ કાર્યોનો ઉપયોગ કરીને એલિસ માટે સ્ટેટફુલ કૌશલ્ય બનાવવું

ચાલો સમાચારથી શરૂઆત કરીએ. ગઈકાલે Yandex.Cloud એ સર્વરલેસ કમ્પ્યુટિંગ સેવા શરૂ કરવાની જાહેરાત કરી હતી યાન્ડેક્ષ ક્લાઉડ કાર્યો. આનો અર્થ છે: તમે ફક્ત તમારી સેવા માટે કોડ લખો છો (ઉદાહરણ તરીકે, વેબ એપ્લિકેશન અથવા ચેટબોટ), અને ક્લાઉડ પોતે વર્ચ્યુઅલ મશીનો બનાવે છે અને જાળવે છે જ્યાં તે ચાલે છે, અને જો લોડ વધે તો તેની નકલ પણ કરે છે. તમારે બિલકુલ વિચારવાની જરૂર નથી, તે ખૂબ અનુકૂળ છે. અને ચુકવણી માત્ર ગણતરી સમય માટે છે.

જો કે, કેટલાક બિલકુલ ચૂકવણી કરી શકતા નથી. આ વિકાસકર્તાઓ છે એલિસની બાહ્ય કુશળતા, એટલે કે, ચેટબોટ્સ તેમાં બિલ્ટ છે. કોઈપણ ડેવલપર આવી કૌશલ્ય લખી, હોસ્ટ અને રજીસ્ટર કરી શકે છે અને આજથી કૌશલ્યને હોસ્ટ કરવાની પણ જરૂર નથી - માત્ર ફોર્મમાં તેમનો કોડ ક્લાઉડ પર અપલોડ કરો સમાન સર્વર વિનાનું કાર્ય.

પરંતુ ત્યાં કેટલાક ઘોંઘાટ છે. સૌપ્રથમ, તમારા પીટ કોડને કેટલીક નિર્ભરતાની જરૂર પડી શકે છે, અને તેમને ક્લાઉડમાં ખેંચવું બિન-તુચ્છ છે. બીજું, કોઈપણ સામાન્ય ચેટબોટને સંવાદની સ્થિતિ ક્યાંક સંગ્રહિત કરવાની જરૂર છે (તેથી સ્ટેટફુલ); સર્વરલેસ ફંક્શનમાં આ કરવાની સૌથી સહેલી રીત કઈ છે? ત્રીજે સ્થાને, તમે એલિસ માટે ઝડપી અને ગંદા કૌશલ્ય કેવી રીતે લખી શકો છો અથવા તો બિન-શૂન્ય પ્લોટ સાથે અમુક પ્રકારના બોટ? લેખ, હકીકતમાં, આ ઘોંઘાટ વિશે છે.

નૈતિક તૈયારી

અધીરા માટે: ક્લાઉડ પર ફંક્શન અપલોડ કરતા પહેલા હું મેકફાઈલ સાથે જરૂરી નિર્ભરતાઓ એકત્રિત કરું છું, હું યાન્ડેક્ષ ઑબ્જેક્ટ સ્ટોરેજમાં સંવાદની સ્થિતિ સંગ્રહિત કરું છું (તે S3 API ને સપોર્ટ કરે છે), અને હું સંવાદનું સંચાલન કરવા માટે મારી પોતાની લાઇબ્રેરીનો ઉપયોગ કરું છું. tgalice. અંતે તે બહાર વળે છે આવા ડેમો કૌશલ્ય. હવે આ બધાને થોડી વધુ વિગતમાં જોઈએ.

થોડા ઓછા અધીરા લોકો માટે, જટિલતા વિશે મારી વાર્તામાં ડાઇવ કરતા પહેલા, હું કંઈક સરળ સાથે પ્રારંભ કરવાની ભલામણ કરું છું. એટલે કે, સિંગલ-ફાઇલ ઇકોબોટ ફંક્શન બનાવો, તેને ડાયલોગ ડેવલપર કન્સોલમાં રજીસ્ટર કરો અને તેનું પરીક્ષણ કરો; વિગતો - માં ડાયલોગ્સ બ્લોગ и મેઘ દસ્તાવેજીકરણ. અને પછી જ શરૂ કરો.

જો તમે તરત જ અનુભવવા માંગતા હોવ કે અમે અહીં શું લડી રહ્યા છીએ, તો એલિસને પૂછો."IT જન્માક્ષર" કૌશલ્યને સક્ષમ કરો' નીચેના જેવો સંવાદ થવો જોઈએ:

એલિસ: હેલો! તમે "IT જન્માક્ષર" કૌશલ્યમાં છો. તારાઓ તમને શું વચન આપે છે તે શોધવા માટે "પ્રારંભ કરો" કહો.
વપરાશકર્તા: પ્રારંભ કરો
A: કૃપા કરીને તમારું નામ જણાવો
યુ: વસીસુઅલી
A: હવે મને તમારા જન્મનું વર્ષ કહો. માત્ર ચાર અંકો, વધારાનું કંઈ નથી.
યુ: સેકન્ડ
A: કૃપા કરીને ફરી પ્રયાસ કરો. તમારા જન્મનું વર્ષ દાખલ કરો - ચાર અંકો.
યુ: 2002
એક મહાન! હવે તમારા જન્મના મહિનાને નામ આપો.
યુ: ફેબ્રુઆરી
એક મહાન! છેલ્લે, મને તમારી જન્મતારીખ જણાવો - માત્ર એક સંખ્યા, માત્ર એક કે બે અંક.
યુ: 18
A: આભાર, વાસીસુઅલી! હવે આપણે જાણીએ છીએ: તમે 17 વર્ષના છો અને એક્વેરિયસના છો. સારું, અલબત્ત, તમે નસીબદાર છો! તારાઓ તમને કહે છે: а что говорят звёзды, вы узнаете, запустив навык.

સમસ્યા એ છે કે આટલો સરળ સંવાદ જાળવવા માટે, તમારે વપરાશકર્તાનું નામ અને જન્મ તારીખ યાદ રાખવાની જરૂર છે, અને સર્વર વિનાના કાર્ય વાતાવરણમાં આ બિન-તુચ્છ છે. સંદર્ભને RAM માં અથવા ડિસ્ક પર ફાઇલ તરીકે સંગ્રહિત કરવાનું શક્ય બનશે નહીં, કારણ કે Yandex.Cloud એક જ સમયે અનેક વર્ચ્યુઅલ મશીનો પર ફંક્શન ચલાવી શકે છે અને તેમની વચ્ચે સ્વિચ કરી શકે છે. તમારે અમુક પ્રકારના બાહ્ય સ્ટોરેજનો ઉપયોગ કરવો પડશે. ઑબ્જેક્ટ સ્ટોરેજને સીધા Yandex.Cloud (એટલે ​​​​કે, કદાચ ઝડપી) માં એકદમ સસ્તું અને જટિલ સ્ટોરેજ તરીકે પસંદ કરવામાં આવ્યું હતું. મફત વિકલ્પ તરીકે, તમે પ્રયાસ કરી શકો છો, ઉદાહરણ તરીકે, એક મફત ભાગ વાદળછાયું મોંગા ક્યાંક દૂર. ઑબ્જેક્ટ સ્ટોરેજ (જે S3 ઇન્ટરફેસને સપોર્ટ કરે છે) અને મોંગો બંને માટે અનુકૂળ પાયથોન રેપર્સ છે.

બીજી સમસ્યા એ છે કે ઑબ્જેક્ટ સ્ટોરેજ, મોંગોડીબી અને અન્ય કોઈપણ ડેટાબેઝ અથવા ડેટા સ્ટોરને ઍક્સેસ કરવા માટે, તમારે કેટલીક બાહ્ય નિર્ભરતાઓની જરૂર છે જે તમારા ફંક્શન કોડ સાથે યાન્ડેક્સ ફંક્શન્સ પર અપલોડ કરવાની જરૂર છે. અને હું આ સુવિધાજનક રીતે કરવા માંગુ છું. કમનસીબે, તે સંપૂર્ણપણે અનુકૂળ રહેશે નહીં (જેમ કે Heroku પર), પરંતુ પર્યાવરણ (ફાઇલ બનાવો) બનાવવા માટે સ્ક્રિપ્ટ લખીને કેટલીક મૂળભૂત આરામ બનાવી શકાય છે.

જન્માક્ષર કૌશલ્ય કેવી રીતે શરૂ કરવું

1. તૈયાર કરો: Linux સાથે અમુક મશીન પર જાઓ. સૈદ્ધાંતિક રીતે, તમે કદાચ વિન્ડોઝ સાથે પણ કામ કરી શકો છો, પરંતુ તે પછી તમારે મેકફાઇલ લોન્ચ કરવા સાથે થોડો જાદુ કરવો પડશે. અને કોઈપણ કિસ્સામાં, તમારે ઓછામાં ઓછું પાયથોન 3.6 ઇન્સ્ટોલ કરવાની જરૂર પડશે.
2. તેને ગીથબથી ક્લોન કરો જન્માક્ષર કૌશલ્યનું ઉદાહરણ.
3. Y.Cloud માં નોંધણી કરો: https://cloud.yandex.ru
4. તમારી જાતને બે ડોલ બનાવો ઑબ્જેક્ટ સ્ટોરેજ, તેમને કોઈપણ નામથી બોલાવો {BUCKET NAME} и tgalice-test-cold-storage (આ બીજું નામ હવે હાર્ડકોડમાં છે main.py મારું ઉદાહરણ). પ્રથમ ડોલ માત્ર જમાવટ માટે જરૂરી રહેશે, બીજી - સંવાદ સ્ટેટ્સ સ્ટોર કરવા માટે.
5. બનાવવા સેવા ખાતું, તેને ભૂમિકા આપો editor, અને તેના માટે સ્થિર ઓળખપત્રો મેળવો {KEY ID} и {KEY VALUE} - અમે તેનો ઉપયોગ સંવાદની સ્થિતિ રેકોર્ડ કરવા માટે કરીશું. આ બધું જરૂરી છે જેથી Ya.Cloud નું ફંક્શન Ya.Cloud માંથી સ્ટોરેજ એક્સેસ કરી શકે. કોઈ દિવસ, હું આશા રાખું છું, અધિકૃતતા આપોઆપ બની જશે, પરંતુ હમણાં માટે તે એવું છે.
6. (વૈકલ્પિક) ઇન્સ્ટોલ કરો આદેશ વાક્ય ઈન્ટરફેસ yc. તમે વેબ ઈન્ટરફેસ દ્વારા ફંક્શન પણ બનાવી શકો છો, પરંતુ CLI સારું છે કારણ કે તેમાં તમામ પ્રકારની નવીનતાઓ ઝડપથી દેખાય છે.
7. હવે તમે ખરેખર નિર્ભરતા એસેમ્બલી તૈયાર કરી શકો છો: કૌશલ્યના ઉદાહરણ સાથે ફોલ્ડરમાંથી કમાન્ડ લાઇન પર ચલાવો make all. ફોલ્ડરમાં પુસ્તકાલયોનો સમૂહ (મોટાભાગે, હંમેશની જેમ, બિનજરૂરી) ઇન્સ્ટોલ કરવામાં આવશે dist.
8. ઓબ્જેક્ટ સ્ટોરેજમાં હાથથી રેડો (ડોલમાં {BUCKET NAME}) પાછલા પગલામાં મેળવેલ આર્કાઇવ dist.zip. જો ઇચ્છિત હોય, તો તમે આ આદેશ વાક્યમાંથી કરી શકો છો, ઉદાહરણ તરીકે, ઉપયોગ કરીને AWS CLI.
9. વેબ ઈન્ટરફેસ દ્વારા અથવા ઉપયોગિતાનો ઉપયોગ કરીને સર્વરલેસ ફંક્શન બનાવો yc. ઉપયોગિતા માટે, આદેશ આના જેવો દેખાશે:

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

મેન્યુઅલી ફંક્શન બનાવતી વખતે, બધા પરિમાણો એ જ રીતે ભરવામાં આવે છે.

હવે તમે બનાવેલ ફંક્શન ડેવલપર કન્સોલ દ્વારા ચકાસી શકાય છે, અને પછી કૌશલ્યને સુધારી અને પ્રકાશિત કરી શકાય છે.

હૂડ હેઠળ શું છે

મેકફાઈલ ખરેખર નિર્ભરતાને સ્થાપિત કરવા અને આર્કાઈવમાં મૂકવા માટે એકદમ સરળ સ્ક્રિપ્ટ ધરાવે છે dist.zip, લગભગ આના જેવું:

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 ./*

બાકીના કેટલાક સરળ સાધનો છે જે લાઇબ્રેરીમાં આવરિત છે tgalice. વપરાશકર્તા ડેટા ભરવાની પ્રક્રિયા રૂપરેખા દ્વારા વર્ણવવામાં આવે છે 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: Пожалуйста, попробуйте ещё раз. Вам нужно назвать число своего рождения (например, двадцатое); это одна или две цифры.

આ રૂપરેખાને પાર્સ કરવાનું અને અંતિમ પરિણામની ગણતરી કરવાનું કામ Python વર્ગ દ્વારા લેવામાં આવે છે

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

વધુ સ્પષ્ટ રીતે, આધાર વર્ગ FormFillingDialogManager "ફોર્મ" ભરવા અને બાળ વર્ગ પદ્ધતિ સાથે વ્યવહાર કરે છે handle_completed_form જ્યારે તેણી તૈયાર થાય ત્યારે શું કરવું તે તેણીને કહે છે.

સંવાદના આ મુખ્ય પ્રવાહ ઉપરાંત, વપરાશકર્તાને પણ શુભેચ્છા પાઠવવી જોઈએ, તેમજ "હેલ્પ" આદેશનો ઉપયોગ કરીને મદદ આપવી જોઈએ અને "એક્ઝિટ" આદેશનો ઉપયોગ કરીને કુશળતામાંથી મુક્ત થવું જોઈએ. આ હેતુ માટે માં tgalice ત્યાં એક ટેમ્પલેટ પણ છે, તેથી સમગ્ર સંવાદ મેનેજર ટુકડાઓથી બનેલો છે:

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 તે સરળ રીતે કાર્ય કરે છે: તે બદલામાં તેના તમામ ઘટકોને સંવાદની વર્તમાન સ્થિતિ પર લાગુ કરવાનો પ્રયાસ કરે છે, અને પ્રથમ યોગ્ય એક પસંદ કરે છે.

ડાયલોગ મેનેજર દરેક સંદેશના પ્રતિભાવ તરીકે પાયથોન ઓબ્જેક્ટ પરત કરે છે. Response, જે પછી સાદા ટેક્સ્ટમાં અથવા એલિસ અથવા ટેલિગ્રામમાં સંદેશમાં રૂપાંતરિત થઈ શકે છે - બોટ ક્યાં ચાલી રહ્યું છે તેના આધારે; તેમાં સંવાદની બદલાયેલી સ્થિતિ પણ છે જેને સાચવવાની જરૂર છે. આ આખું રસોડું અન્ય વર્ગ સંભાળે છે, DialogConnector, તેથી યાન્ડેક્ષ ફંક્શન્સ પર કૌશલ્ય શરૂ કરવા માટેની સીધી સ્ક્રિપ્ટ આના જેવી દેખાય છે:

...
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

જેમ તમે જોઈ શકો છો, આમાંનો મોટા ભાગનો કોડ ઑબ્જેક્ટ સ્ટોરેજના S3 ઇન્ટરફેસ સાથે જોડાણ બનાવે છે. તમે વાંચી શકો છો કે આ કનેક્શનનો સીધો ઉપયોગ કેવી રીતે થાય છે tgalice કોડમાં.
છેલ્લી લીટી ફંક્શન બનાવે છે alice_handler — તે જ જે અમે Yandex.Cloud ને જ્યારે પેરામીટર સેટ કરીએ ત્યારે ખેંચવાનું કહ્યું હતું --entrypoint=main.alice_handler.

તે બધા છે, વાસ્તવમાં. એસેમ્બલી માટે મેકફાઈલ્સ, સંદર્ભ સ્ટોર કરવા માટે S3 જેવી ઑબ્જેક્ટ સ્ટોરેજ અને પાયથોન લાઇબ્રેરી tgalice. સર્વરલેસ કાર્યો અને પાયથોનની અભિવ્યક્તિ સાથે જોડાઈને, આ તંદુરસ્ત માનવ કૌશલ્ય વિકસાવવા માટે પૂરતું છે.

તમે પૂછી શકો છો કે શા માટે તે બનાવવું જરૂરી હતું tgalice? બધા બોરિંગ કોડ કે જે JSON ને વિનંતીથી પ્રતિસાદ અને સ્ટોરેજથી મેમરી અને બેકમાં સ્થાનાંતરિત કરે છે તે તેમાં રહેલ છે. એક નિયમિત કોડ એપ્લિકેશન પણ છે, જે સમજવા માટેનું કાર્ય છે કે “ફેબ્રુઆરી” “ફેબ્રુઆરી” સમાન છે, અને ગરીબો માટે અન્ય NLU. મારા વિચાર મુજબ, આ પહેલેથી જ પૂરતું હોવું જોઈએ જેથી તમે તકનીકી વિગતોથી ખૂબ વિચલિત થયા વિના yaml ફાઇલોમાં કુશળતાના પ્રોટોટાઇપનું સ્કેચ કરી શકો.

જો તમને વધુ ગંભીર NLU જોઈએ છે, તો તમે તેને તમારી કુશળતા સાથે જોડી શકો છો રાસા અથવા દીપપાવલોવ, પરંતુ તેમને સેટ કરવા માટે ખંજરી સાથે વધારાના નૃત્યોની જરૂર પડશે, ખાસ કરીને સર્વરલેસ પર. જો તમને કોડિંગ કરવાનું બિલકુલ ન લાગે, તો તમારે વિઝ્યુઅલ કન્સ્ટ્રક્ટરનો ઉપયોગ કરવો જોઈએ એમાયલોજિક. tgalice બનાવતી વખતે, મેં અમુક પ્રકારના મધ્યવર્તી માર્ગ વિશે વિચાર્યું. ચાલો જોઈએ કે આમાંથી શું આવે છે.

સારું, હવે જોડાઓ એલિસ સ્કિલ ડેવલપર ચેટ, વાંચવું દસ્તાવેજીકરણ, અને અદ્ભુત બનાવો કુશળતા!

સોર્સ: www.habr.com