{"id":2004,"date":"2022-03-23T01:44:57","date_gmt":"2022-03-23T01:44:57","guid":{"rendered":"https:\/\/salarydistribution.com\/machine-learning\/2022\/03\/23\/expedite-ivr-development-with-industry-grammars-on-amazon-lex\/"},"modified":"2022-03-23T01:44:57","modified_gmt":"2022-03-23T01:44:57","slug":"expedite-ivr-development-with-industry-grammars-on-amazon-lex","status":"publish","type":"post","link":"https:\/\/salarydistribution.com\/machine-learning\/2022\/03\/23\/expedite-ivr-development-with-industry-grammars-on-amazon-lex\/","title":{"rendered":"Expedite IVR development with industry grammars on Amazon Lex"},"content":{"rendered":"
\n

Amazon Lex<\/a> is a service for building conversational interfaces into any application using voice and text. With Amazon Lex, you can easily build sophisticated, natural language, conversational bots (chatbots), virtual agents, and interactive voice response (IVR) systems. You can now use industry grammars to accelerate IVR development on Amazon Lex as part of your IVR migration effort. Industry grammars are a set of XML files made available as a grammar slot type<\/a>. You can select from a range of pre-built industry grammars across domains, such as financial services, insurance, and telecom. In this post, we review the industry grammars for these industries and use them to create IVR experiences.<\/p>\n

Financial services<\/h2>\n

You can use Amazon Lex in the financial services domain to automate customer service interactions such as credit card payments, mortgage loan applications, portfolio status, and account updates. During these interactions, the IVR flow needs to collect several details, including credit card number, mortgage loan ID, and portfolio details, to fulfill the user\u2019s request. We use the financial services industry grammars in the following sample conversation:<\/p>\n

Agent: Welcome to ACME bank. To get started, can I get your account ID?<\/em><\/p>\n

User: Yes, it\u2019s AB12345.<\/em><\/p>\n

IVR: Got it. How can I help you?<\/em><\/p>\n

User: I\u2019d like to transfer funds to my savings account.<\/em><\/p>\n

IVR: Sure. How much would you like to transfer?<\/em><\/p>\n

User: $100<\/em><\/p>\n

IVR: Great, thank you.<\/em><\/p>\n

The following grammars are supported for financial services: account ID, credit card number, transfer amount, and different date formats such as expiration date (mm\/yy) and payment date (mm\/dd).<\/p>\n

Let\u2019s review the sample\u00a0account ID<\/a> grammar. You can refer to the other grammars in the documentation<\/a>.<\/p>\n

\n
<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<grammar xmlns=\"http:\/\/www.w3.org\/2001\/06\/grammar\"\n         xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n         xsi:schemaLocation=\"http:\/\/www.w3.org\/2001\/06\/grammar\n                             http:\/\/www.w3.org\/TR\/speech-grammar\/grammar.xsd\"\n         xml:lang=\"en-US\" version=\"1.0\"\n         root=\"main\"\n         mode=\"voice\"\n         tag-format=\"semantics\/1.0\">\n\n\n        <!-- Test Cases\n\n        Grammar will support the following inputs:\n\n            Scenario 1:\n                Input: My account number is A B C 1 2 3 4\n                Output: ABC1234\n\n            Scenario 2:\n                Input: My account number is 1 2 3 4 A B C\n                Output: 1234ABC\n\n            Scenario 3:\n                Input: Hmm My account number is 1 2 3 4 A B C 1\n                Output: 123ABC1\n        -->\n\n        <rule id=\"main\" scope=\"public\">\n            <tag>out=\"\"<\/tag>\n            <item><ruleref uri=\"#alphanumeric\"\/><tag>out += rules.alphanumeric.alphanum;<\/tag><\/item>\n            <item repeat=\"0-1\"><ruleref uri=\"#alphabets\"\/><tag>out += rules.alphabets.letters;<\/tag><\/item>\n            <item repeat=\"0-1\"><ruleref uri=\"#digits\"\/><tag>out += rules.digits.numbers<\/tag><\/item>\n        <\/rule>\n\n        <rule id=\"text\">\n            <item repeat=\"0-1\"><ruleref uri=\"#hesitation\"\/><\/item>\n            <one-of>\n                <item repeat=\"0-1\">account number is<\/item>\n                <item repeat=\"0-1\">Account Number<\/item>\n                <item repeat=\"0-1\">Here is my Account Number <\/item>\n                <item repeat=\"0-1\">Yes, It is<\/item>\n                <item repeat=\"0-1\">Yes It is<\/item>\n                <item repeat=\"0-1\">Yes It's<\/item>\n                <item repeat=\"0-1\">My account Id is<\/item>\n                <item repeat=\"0-1\">This is the account Id<\/item>\n                <item repeat=\"0-1\">account Id<\/item>\n            <\/one-of>\n        <\/rule>\n\n        <rule id=\"hesitation\">\n          <one-of>\n             <item>Hmm<\/item>\n             <item>Mmm<\/item>\n             <item>My<\/item>\n          <\/one-of>\n        <\/rule>\n\n        <rule id=\"alphanumeric\" scope=\"public\">\n            <tag>out.alphanum=\"\"<\/tag>\n            <item><ruleref uri=\"#alphabets\"\/><tag>out.alphanum += rules.alphabets.letters;<\/tag><\/item>\n            <item repeat=\"0-1\"><ruleref uri=\"#digits\"\/><tag>out.alphanum += rules.digits.numbers<\/tag><\/item>\n        <\/rule>\n\n        <rule id=\"alphabets\">\n            <item repeat=\"0-1\"><ruleref uri=\"#text\"\/><\/item>\n            <tag>out.letters=\"\"<\/tag>\n            <tag>out.firstOccurence=\"\"<\/tag>\n            <item repeat=\"0-1\"><ruleref uri=\"#digits\"\/><tag>out.firstOccurence += rules.digits.numbers; out.letters += out.firstOccurence;<\/tag><\/item>\n            <item repeat=\"1-\">\n                <one-of>\n                    <item>A<tag>out.letters+='A';<\/tag><\/item>\n                    <item>B<tag>out.letters+='B';<\/tag><\/item>\n                    <item>C<tag>out.letters+='C';<\/tag><\/item>\n                    <item>D<tag>out.letters+='D';<\/tag><\/item>\n                    <item>E<tag>out.letters+='E';<\/tag><\/item>\n                    <item>F<tag>out.letters+='F';<\/tag><\/item>\n                    <item>G<tag>out.letters+='G';<\/tag><\/item>\n                    <item>H<tag>out.letters+='H';<\/tag><\/item>\n                    <item>I<tag>out.letters+='I';<\/tag><\/item>\n                    <item>J<tag>out.letters+='J';<\/tag><\/item>\n                    <item>K<tag>out.letters+='K';<\/tag><\/item>\n                    <item>L<tag>out.letters+='L';<\/tag><\/item>\n                    <item>M<tag>out.letters+='M';<\/tag><\/item>\n                    <item>N<tag>out.letters+='N';<\/tag><\/item>\n                    <item>O<tag>out.letters+='O';<\/tag><\/item>\n                    <item>P<tag>out.letters+='P';<\/tag><\/item>\n                    <item>Q<tag>out.letters+='Q';<\/tag><\/item>\n                    <item>R<tag>out.letters+='R';<\/tag><\/item>\n                    <item>S<tag>out.letters+='S';<\/tag><\/item>\n                    <item>T<tag>out.letters+='T';<\/tag><\/item>\n                    <item>U<tag>out.letters+='U';<\/tag><\/item>\n                    <item>V<tag>out.letters+='V';<\/tag><\/item>\n                    <item>W<tag>out.letters+='W';<\/tag><\/item>\n                    <item>X<tag>out.letters+='X';<\/tag><\/item>\n                    <item>Y<tag>out.letters+='Y';<\/tag><\/item>\n                    <item>Z<tag>out.letters+='Z';<\/tag><\/item>\n                <\/one-of>\n            <\/item>\n        <\/rule>\n\n        <rule id=\"digits\">\n            <item repeat=\"0-1\"><ruleref uri=\"#text\"\/><\/item>\n            <tag>out.numbers=\"\"<\/tag>\n            <item repeat=\"1-10\">\n                <one-of>\n                    <item>0<tag>out.numbers+=0;<\/tag><\/item>\n                    <item>1<tag>out.numbers+=1;<\/tag><\/item>\n                    <item>2<tag>out.numbers+=2;<\/tag><\/item>\n                    <item>3<tag>out.numbers+=3;<\/tag><\/item>\n                    <item>4<tag>out.numbers+=4;<\/tag><\/item>\n                    <item>5<tag>out.numbers+=5;<\/tag><\/item>\n                    <item>6<tag>out.numbers+=6;<\/tag><\/item>\n                    <item>7<tag>out.numbers+=7;<\/tag><\/item>\n                    <item>8<tag>out.numbers+=8;<\/tag><\/item>\n                    <item>9<tag>out.numbers+=9;<\/tag><\/item>\n                <\/one-of>\n            <\/item>\n        <\/rule>\n<\/grammar><\/code><\/pre>\n<\/p><\/div>\n
Using the industry grammar for financial services<\/h3>\n
To create the sample bot and add the grammars, perform the following steps. This creates an Amazon Lex bot called Financialbot<\/code> and adds the grammars for financial services, which we store in Amazon Simple Storage Service<\/a> (Amazon S3):<\/p>\n
    \n
  1. Download the Amazon Lex bot definition<\/a>.<\/li>\n
  2. On the Amazon Lex console, choose Actions <\/strong>and then choose Import<\/strong>.<\/li>\n
  3. Choose the Financialbot.zip<\/code> file that you downloaded, and choose Import<\/strong>.<\/li>\n
  4. Copy the grammar XML files<\/a> for financial services, listed in the preceding section.<\/li>\n
  5. On the Amazon S3 console, upload the XML files.<\/li>\n
  6. Navigate to the slot types on the Amazon Lex console and choose the accountID<\/code> slot type so you can associate the fin_accountNumber.grxml<\/code> file.<\/li>\n
  7. In the slot type, enter the Amazon S3 link for the XML file and the object key.<\/li>\n
  8. Choose Save slot type<\/strong>.<\/li>\n<\/ol>\n
    The AWS Identity and Access Management<\/a> (IAM) role used to create the bot must have permission to read files from the S3 bucket.<\/p>\n
      \n
    1. Repeat steps 6\u20138 for the transferFunds<\/code> slot type with fin_transferAmount.grxml<\/code>.<\/li>\n
    2. After you save the grammars, choose Build<\/strong>.<\/li>\n
    3. Download the financial services contact flow<\/a> to integrate it with the Amazon Lex bot via Amazon Connect<\/a>.<\/li>\n
    4. On the Amazon Connect console, choose Contact flows<\/strong>.<\/li>\n
    5. In the Amazon Lex<\/strong> section, select your Amazon Lex bot and make it available for use in the Amazon Connect contact flows.<\/li>\n
    6. Select the contact flow to load it into the application.<\/li>\n
    7. Test the IVR flow by calling in to the phone number.<\/li>\n<\/ol>\n
      Insurance<\/h2>\n
      You can use Amazon Lex in the insurance domain to automate customer service interactions such as claims processing, policy management, and premium payments. During these interactions, the IVR flow needs to collect several details, including policy ID, license plate, and premium amount, to fulfill the policy holder\u2019s request. We use the insurance industry grammars in the following sample conversation:<\/p>\n
      Agent: Welcome to ACME insurance company. To get started, can I get your policy ID?<\/em><\/p>\n
      Caller: Yes, it\u2019s AB1234567.<\/em><\/p>\n
      IVR: Got it. How can I help you?<\/em><\/p>\n
      Caller: I\u2019d like to file a claim.<\/em><\/p>\n
      IVR: Sure. Is this claim regarding your auto policy or home owners\u2019 policy?<\/em><\/p>\n
      Caller: Auto<\/em><\/p>\n
      IVR: What\u2019s the license plate on the vehicle?<\/em><\/p>\n
      Caller: ABCD1234<\/em><\/p>\n
      IVR: Thank you. And how much is the claim for?<\/em><\/p>\n
      Caller: $900<\/em><\/p>\n
      IVR: What was the date and time of the accident?<\/em><\/p>\n
      Caller: March 1st 2:30pm.<\/em><\/p>\n
      IVR: Thank you. I\u2019ve got that started for you. Someone from our office should be in touch with you shortly. Your claim ID is 12345.<\/em><\/p>\n
      The following grammars are supported for the insurance domain: policy ID, driver\u2019s license, social security number, license plate, claim number, and renewal date.<\/p>\n
      Let\u2019s review the sample claimDateTime<\/a> grammar. You can refer to the other grammars in the documentation<\/a>.<\/p>\n
      \n
      <?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<grammar xmlns=\"http:\/\/www.w3.org\/2001\/06\/grammar\"\n         xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n         xsi:schemaLocation=\"http:\/\/www.w3.org\/2001\/06\/grammar\n                             http:\/\/www.w3.org\/TR\/speech-grammar\/grammar.xsd\"\n         xml:lang=\"en-US\" version=\"1.0\"\n         root=\"main\"\n         mode=\"voice\"\n         tag-format=\"semantics\/1.0\">\n\n         <!-- Test Cases\n\n         Grammar will support the following inputs:\n\n             Scenario 1:\n                 Input: The accident occured at july three at five am\n                 Output:  july 3 5am\n\n             Scenario 2:\n                 Input: Damage was reported at july three at five am\n                 Output:  july 3 5am\n\n             Scenario 3:\n                 Input: Schedule virtual inspection for july three at five am\n                 Output:  july 3 5am\n         -->\n\n        <rule id=\"main\" scope=\"public\">\n            <tag>out=\"\"<\/tag>\n            <item repeat=\"1-10\">\n                <item><ruleref uri=\"#months\"\/><tag>out = out + rules.months + \" \";<\/tag><\/item>\n                <one-of>\n                    <item><ruleref uri=\"#digits\"\/><tag>out += rules.digits + \" \";<\/tag><\/item>\n                    <item><ruleref uri=\"#teens\"\/><tag>out += rules.teens+ \" \";<\/tag><\/item>\n                    <item><ruleref uri=\"#above_twenty\"\/><tag>out += rules.above_twenty+ \" \";<\/tag><\/item>\n                <\/one-of>\n                <item><ruleref uri=\"#at\"\/><tag>out += rules.at.new;<\/tag><\/item>\n                <item repeat=\"0-1\"><ruleref uri=\"#mins\"\/><tag>out +=\":\" + rules.mins.min;<\/tag><\/item>\n                <item><ruleref uri=\"#ampm\"\/><tag>out += rules.ampm;<\/tag><\/item>\n            <\/item>\n            <item repeat=\"0-1\"><ruleref uri=\"#thanks\"\/><\/item>\n        <\/rule>\n\n        <rule id=\"text\">\n           <one-of>\n             <item repeat=\"0-1\">The accident occured at<\/item>\n             <item repeat=\"0-1\">Time of accident is<\/item>\n             <item repeat=\"0-1\">Damage was reported at<\/item>\n             <item repeat=\"0-1\">Schedule virtual inspection for<\/item>\n           <\/one-of>\n        <\/rule>\n\n        <rule id=\"thanks\">\n            <one-of>\n               <item>Thanks<\/item>\n               <item>I think<\/item>\n            <\/one-of>\n          <\/rule>\n\n        <rule id=\"months\">\n           <item repeat=\"0-1\"><ruleref uri=\"#text\"\/><\/item>\n           <one-of>\n             <item>january<tag>out=\"january\";<\/tag><\/item>\n             <item>february<tag>out=\"february\";<\/tag><\/item>\n             <item>march<tag>out=\"march\";<\/tag><\/item>\n             <item>april<tag>out=\"april\";<\/tag><\/item>\n             <item>may<tag>out=\"may\";<\/tag><\/item>\n             <item>june<tag>out=\"june\";<\/tag><\/item>\n             <item>july<tag>out=\"july\";<\/tag><\/item>\n             <item>august<tag>out=\"august\";<\/tag><\/item>\n             <item>september<tag>out=\"september\";<\/tag><\/item>\n             <item>october<tag>out=\"october\";<\/tag><\/item>\n             <item>november<tag>out=\"november\";<\/tag><\/item>\n             <item>december<tag>out=\"december\";<\/tag><\/item>\n             <item>jan<tag>out=\"january\";<\/tag><\/item>\n             <item>feb<tag>out=\"february\";<\/tag><\/item>\n             <item>aug<tag>out=\"august\";<\/tag><\/item>\n             <item>sept<tag>out=\"september\";<\/tag><\/item>\n             <item>oct<tag>out=\"october\";<\/tag><\/item>\n             <item>nov<tag>out=\"november\";<\/tag><\/item>\n             <item>dec<tag>out=\"december\";<\/tag><\/item>\n           <\/one-of>\n       <\/rule>\n\n        <rule id=\"digits\">\n            <one-of>\n                <item>0<tag>out=0;<\/tag><\/item>\n                <item>1<tag>out=1;<\/tag><\/item>\n                <item>2<tag>out=2;<\/tag><\/item>\n                <item>3<tag>out=3;<\/tag><\/item>\n                <item>4<tag>out=4;<\/tag><\/item>\n                <item>5<tag>out=5;<\/tag><\/item>\n                <item>6<tag>out=6;<\/tag><\/item>\n                <item>7<tag>out=7;<\/tag><\/item>\n                <item>8<tag>out=8;<\/tag><\/item>\n                <item>9<tag>out=9;<\/tag><\/item>\n                <item>first<tag>out=1;<\/tag><\/item>\n                <item>second<tag>out=2;<\/tag><\/item>\n                <item>third<tag>out=3;<\/tag><\/item>\n                <item>fourth<tag>out=4;<\/tag><\/item>\n                <item>fifth<tag>out=5;<\/tag><\/item>\n                <item>sixth<tag>out=6;<\/tag><\/item>\n                <item>seventh<tag>out=7;<\/tag><\/item>\n                <item>eighth<tag>out=8;<\/tag><\/item>\n                <item>ninth<tag>out=9;<\/tag><\/item>\n                <item>one<tag>out=1;<\/tag><\/item>\n                <item>two<tag>out=2;<\/tag><\/item>\n                <item>three<tag>out=3;<\/tag><\/item>\n                <item>four<tag>out=4;<\/tag><\/item>\n                <item>five<tag>out=5;<\/tag><\/item>\n                <item>six<tag>out=6;<\/tag><\/item>\n                <item>seven<tag>out=7;<\/tag><\/item>\n                <item>eight<tag>out=8;<\/tag><\/item>\n                <item>nine<tag>out=9;<\/tag><\/item>\n            <\/one-of>\n        <\/rule>\n\n\n      <rule id=\"at\">\n        <tag>out.new=\"\"<\/tag>\n        <item>at<\/item>\n        <one-of>\n          <item repeat=\"0-1\"><ruleref uri=\"#digits\"\/><tag>out.new+= rules.digits<\/tag><\/item>\n          <item repeat=\"0-1\"><ruleref uri=\"#teens\"\/><tag>out.new+= rules.teens<\/tag><\/item>\n        <\/one-of>\n      <\/rule>\n\n      <rule id=\"mins\">\n        <tag>out.min=\"\"<\/tag>\n        <item repeat=\"0-1\">:<\/item>\n        <item repeat=\"0-1\">and<\/item>\n        <one-of>\n          <item repeat=\"0-1\"><ruleref uri=\"#digits\"\/><tag>out.min+= rules.digits<\/tag><\/item>\n          <item repeat=\"0-1\"><ruleref uri=\"#teens\"\/><tag>out.min+= rules.teens<\/tag><\/item>\n          <item repeat=\"0-1\"><ruleref uri=\"#above_twenty\"\/><tag>out.min+= rules.above_twenty<\/tag><\/item>\n        <\/one-of>\n      <\/rule>\n\n      <rule id=\"ampm\">\n            <tag>out=\"\"<\/tag>\n            <one-of>\n                <item>AM<tag>out=\"am\";<\/tag><\/item>\n                <item>PM<tag>out=\"pm\";<\/tag><\/item>\n                <item>am<tag>out=\"am\";<\/tag><\/item>\n                <item>pm<tag>out=\"pm\";<\/tag><\/item>\n            <\/one-of>\n        <\/rule>\n\n\n        <rule id=\"teens\">\n            <one-of>\n                <item>ten<tag>out=10;<\/tag><\/item>\n                <item>tenth<tag>out=10;<\/tag><\/item>\n                <item>eleven<tag>out=11;<\/tag><\/item>\n                <item>twelve<tag>out=12;<\/tag><\/item>\n                <item>thirteen<tag>out=13;<\/tag><\/item>\n                <item>fourteen<tag>out=14;<\/tag><\/item>\n                <item>fifteen<tag>out=15;<\/tag><\/item>\n                <item>sixteen<tag>out=16;<\/tag><\/item>\n                <item>seventeen<tag>out=17;<\/tag><\/item>\n                <item>eighteen<tag>out=18;<\/tag><\/item>\n                <item>nineteen<tag>out=19;<\/tag><\/item>\n                <item>tenth<tag>out=10;<\/tag><\/item>\n                <item>eleventh<tag>out=11;<\/tag><\/item>\n                <item>twelveth<tag>out=12;<\/tag><\/item>\n                <item>thirteenth<tag>out=13;<\/tag><\/item>\n                <item>fourteenth<tag>out=14;<\/tag><\/item>\n                <item>fifteenth<tag>out=15;<\/tag><\/item>\n                <item>sixteenth<tag>out=16;<\/tag><\/item>\n                <item>seventeenth<tag>out=17;<\/tag><\/item>\n                <item>eighteenth<tag>out=18;<\/tag><\/item>\n                <item>nineteenth<tag>out=19;<\/tag><\/item>\n            <\/one-of>\n        <\/rule>\n\n        <rule id=\"above_twenty\">\n            <one-of>\n                <item>twenty<tag>out=20;<\/tag><\/item>\n                <item>thirty<tag>out=30;<\/tag><\/item>\n            <\/one-of>\n            <item repeat=\"0-1\"><ruleref uri=\"#digits\"\/><tag>out += rules.digits;<\/tag><\/item>\n        <\/rule>\n<\/grammar><\/code><\/pre>\n<\/p><\/div>\n
      Using the industry grammar for insurance<\/h3>\n
      To create the sample bot and add the grammars, perform the following steps. This creates an Amazon Lex bot called InsuranceBot<\/code> and adds the grammars for the insurance domain:<\/p>\n
        \n
      1. Download the Amazon Lex bot definition<\/a>.<\/li>\n
      2. On the Amazon Lex console, choose Actions<\/strong>, then choose Import<\/strong>.<\/li>\n
      3. Choose the InsuranceBot.zip file<\/code> that you downloaded, and choose Import<\/strong>.<\/li>\n
      4. Copy the grammar XML files<\/a> for insurance, listed in the preceding section.<\/li>\n
      5. On the Amazon S3 console, upload the XML files.<\/li>\n
      6. Navigate to the slot types on the Amazon Lex console and select the policyID<\/code> slot type so you can associate the ins_policyNumber.grxml<\/code> grammar file.<\/li>\n
      7. In the slot type, enter the Amazon S3 link for the XML file and the object key.<\/li>\n
      8. Choose Save slot type<\/strong>.<\/li>\n<\/ol>\n
        The IAM role used to create the bot must have permission to read files from the S3 bucket.<\/p>\n
          \n
        1. Repeat steps 6\u20138 for the licensePlate<\/code> slot type (ins_NJ_licensePlateNumber.grxml<\/code>) and dateTime<\/code> slot type (ins_claimDateTime.grxml<\/code>).<\/li>\n
        2. After you save the grammars, choose Build<\/strong>.<\/li>\n
        3. Download the insurance contact flow<\/a> to integrate with the Amazon Lex bot.<\/li>\n
        4. On the Amazon Connect console, choose Contact flows<\/strong>.<\/li>\n
        5. In the Amazon Lex<\/strong> section, and select your Lex bot and make it available for use in the Amazon Connect contact flows.<\/li>\n
        6. Select the contact flow to load it into the application.<\/li>\n
        7. Test the IVR flow by calling in to the phone number.<\/li>\n<\/ol>\n
          Telecom<\/h2>\n
          You can use Amazon Lex in the telecom domain to automate customer service interactions such as activating service, paying bills, and managing device installations. During these interactions, the IVR flow needs to collect several details, including SIM number, zip code, and the service start date, to fulfill the user\u2019s request. We use the financial services industry grammars in the following sample conversation:<\/p>\n
          Agent: Welcome to ACME cellular. To get started, can I have the telephone number associated with your account?<\/em><\/p>\n
          User: Yes, it\u2019s 123 456 7890.<\/em><\/p>\n
          IVR: Thanks. How can I help you?<\/em><\/p>\n
          User: I am calling to activate my service.<\/em><\/p>\n
          IVR: Sure. What\u2019s the SIM number on the device?<\/em><\/p>\n
          IVR: 12345ABC<\/em><\/p>\n
          IVR: Ok. And can I have the zip code?<\/em><\/p>\n
          User: 12345<\/em><\/p>\n
          IVR: Great, thank you. The device has been activated.<\/em><\/p>\n
          The following grammars are supported for telecom: SIM number, device serial number, zip code, phone number, service start date, and ordinals.<\/p>\n
          Let\u2019s review the sample SIM number<\/a> grammar. You can refer to the other grammars in the documentation<\/a>.<\/p>\n
          \n
          <?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<grammar xmlns=\"http:\/\/www.w3.org\/2001\/06\/grammar\"\n         xmlns:xsi=\"http:\/\/www.w3.org\/2001\/XMLSchema-instance\"\n         xsi:schemaLocation=\"http:\/\/www.w3.org\/2001\/06\/grammar\n                             http:\/\/www.w3.org\/TR\/speech-grammar\/grammar.xsd\"\n         xml:lang=\"en-US\" version=\"1.0\"\n         root=\"main\"\n         mode=\"voice\"\n         tag-format=\"semantics\/1.0\">\n\n\n        <!-- Test Cases\n\n        Grammar will support the following inputs:\n\n            Scenario 1:\n                Input: My SIM number is A B C 1 2 3 4\n                Output: ABC1234\n\n            Scenario 2:\n                Input: My SIM number is 1 2 3 4 A B C\n                Output: 1234ABC\n\n            Scenario 3:\n                Input: My SIM number is 1 2 3 4 A B C 1\n                Output: 123ABC1\n        -->\n\n        <rule id=\"main\" scope=\"public\">\n            <tag>out=\"\"<\/tag>\n            <item><ruleref uri=\"#alphanumeric\"\/><tag>out += rules.alphanumeric.alphanum;<\/tag><\/item>\n            <item repeat=\"0-1\"><ruleref uri=\"#alphabets\"\/><tag>out += rules.alphabets.letters;<\/tag><\/item>\n            <item repeat=\"0-1\"><ruleref uri=\"#digits\"\/><tag>out += rules.digits.numbers<\/tag><\/item>\n        <\/rule>\n\n        <rule id=\"text\">\n            <item repeat=\"0-1\"><ruleref uri=\"#hesitation\"\/><\/item>\n            <one-of>\n                <item repeat=\"0-1\">My SIM number is<\/item>\n                <item repeat=\"0-1\">SIM number is<\/item>\n            <\/one-of>\n        <\/rule>\n\n        <rule id=\"hesitation\">\n          <one-of>\n             <item>Hmm<\/item>\n             <item>Mmm<\/item>\n             <item>My<\/item>\n          <\/one-of>\n        <\/rule>\n\n        <rule id=\"alphanumeric\" scope=\"public\">\n            <tag>out.alphanum=\"\"<\/tag>\n            <item><ruleref uri=\"#alphabets\"\/><tag>out.alphanum += rules.alphabets.letters;<\/tag><\/item>\n            <item repeat=\"0-1\"><ruleref uri=\"#digits\"\/><tag>out.alphanum += rules.digits.numbers<\/tag><\/item>\n        <\/rule>\n\n        <rule id=\"alphabets\">\n            <item repeat=\"0-1\"><ruleref uri=\"#text\"\/><\/item>\n            <tag>out.letters=\"\"<\/tag>\n            <tag>out.firstOccurence=\"\"<\/tag>\n            <item repeat=\"0-1\"><ruleref uri=\"#digits\"\/><tag>out.firstOccurence += rules.digits.numbers; out.letters += out.firstOccurence;<\/tag><\/item>\n            <item repeat=\"1-\">\n                <one-of>\n                    <item>A<tag>out.letters+='A';<\/tag><\/item>\n                    <item>B<tag>out.letters+='B';<\/tag><\/item>\n                    <item>C<tag>out.letters+='C';<\/tag><\/item>\n                    <item>D<tag>out.letters+='D';<\/tag><\/item>\n                    <item>E<tag>out.letters+='E';<\/tag><\/item>\n                    <item>F<tag>out.letters+='F';<\/tag><\/item>\n                    <item>G<tag>out.letters+='G';<\/tag><\/item>\n                    <item>H<tag>out.letters+='H';<\/tag><\/item>\n                    <item>I<tag>out.letters+='I';<\/tag><\/item>\n                    <item>J<tag>out.letters+='J';<\/tag><\/item>\n                    <item>K<tag>out.letters+='K';<\/tag><\/item>\n                    <item>L<tag>out.letters+='L';<\/tag><\/item>\n                    <item>M<tag>out.letters+='M';<\/tag><\/item>\n                    <item>N<tag>out.letters+='N';<\/tag><\/item>\n                    <item>O<tag>out.letters+='O';<\/tag><\/item>\n                    <item>P<tag>out.letters+='P';<\/tag><\/item>\n                    <item>Q<tag>out.letters+='Q';<\/tag><\/item>\n                    <item>R<tag>out.letters+='R';<\/tag><\/item>\n                    <item>S<tag>out.letters+='S';<\/tag><\/item>\n                    <item>T<tag>out.letters+='T';<\/tag><\/item>\n                    <item>U<tag>out.letters+='U';<\/tag><\/item>\n                    <item>V<tag>out.letters+='V';<\/tag><\/item>\n                    <item>W<tag>out.letters+='W';<\/tag><\/item>\n                    <item>X<tag>out.letters+='X';<\/tag><\/item>\n                    <item>Y<tag>out.letters+='Y';<\/tag><\/item>\n                    <item>Z<tag>out.letters+='Z';<\/tag><\/item>\n                <\/one-of>\n            <\/item>\n        <\/rule>\n\n        <rule id=\"digits\">\n            <item repeat=\"0-1\"><ruleref uri=\"#text\"\/><\/item>\n            <tag>out.numbers=\"\"<\/tag>\n            <item repeat=\"1-10\">\n                <one-of>\n                    <item>0<tag>out.numbers+=0;<\/tag><\/item>\n                    <item>1<tag>out.numbers+=1;<\/tag><\/item>\n                    <item>2<tag>out.numbers+=2;<\/tag><\/item>\n                    <item>3<tag>out.numbers+=3;<\/tag><\/item>\n                    <item>4<tag>out.numbers+=4;<\/tag><\/item>\n                    <item>5<tag>out.numbers+=5;<\/tag><\/item>\n                    <item>6<tag>out.numbers+=6;<\/tag><\/item>\n                    <item>7<tag>out.numbers+=7;<\/tag><\/item>\n                    <item>8<tag>out.numbers+=8;<\/tag><\/item>\n                    <item>9<tag>out.numbers+=9;<\/tag><\/item>\n                <\/one-of>\n            <\/item>\n        <\/rule>\n<\/grammar><\/code><\/pre>\n<\/p><\/div>\n
          Using the industry grammar for telecom<\/h3>\n
          To create the sample bot and add the grammars, perform the following steps. This creates an Amazon Lex bot called TelecomBot<\/code> and adds the grammars for telecom:<\/p>\n
            \n
          1. Download the Amazon Lex bot definition<\/a>.<\/li>\n
          2. On the Amazon Lex console, choose Actions<\/strong>, then choose Import<\/strong>.<\/li>\n
          3. Choose the TelecomBot.zip<\/code> file that you downloaded, and choose Import<\/strong>.<\/li>\n
          4. Copy the grammar XML files<\/a> for the telecom domain, listed in the preceding section.<\/li>\n
          5. On the Amazon S3 console, upload the XML files.<\/li>\n
          6. Navigate to the slot types on the Amazon Lex console and select phoneNumber<\/code> so you can associate the tel_phoneNumber.grxml<\/code> grammar.<\/li>\n
          7. In the slot type, enter the Amazon S3 link for the XML file and the object key.<\/li>\n
          8. Choose Save slot type<\/strong>.<\/li>\n<\/ol>\n
            The IAM role used to create the bot must have permission to read files from the S3 bucket.<\/p>\n
              \n
            1. Repeat steps 6\u20138 for the slot types SIM number<\/code> (tel_simNumber.grxml<\/code>) and zipcode<\/code> (tel_usZipcode.grxml<\/code>).<\/li>\n
            2. After you save the grammars, choose Build<\/strong>.<\/li>\n
            3. Download the insurance contact flow<\/a> to integrate with the Amazon Lex bot.<\/li>\n
            4. On the Amazon Connect console, choose Contact flows<\/strong>.<\/li>\n
            5. In the Amazon Lex<\/strong> section, and select your Amazon Lex bot and make it available for use in the Amazon Connect contact flows.<\/li>\n
            6. Select the contact flow to load it into the application.<\/li>\n
            7. Test the IVR flow by calling in to the phone number.<\/li>\n<\/ol>\n
              Test the solution<\/h2>\n
              You can call in to the Amazon Connect phone number and interact with the bot. You can also test the solution directly on the Amazon Lex V2 console using voice or text.<\/p>\n
              Conclusion<\/h2>\n
              Industry grammars provide a set of pre-built XML files that you can use to quickly create IVR flows. You can select grammars to enable customer service conversations for use cases across financial services, insurance, and telecom. The grammars are available as a grammar slot type<\/a> and can be used in an Amazon Lex bot configuration. You can download the grammars and enable these via the Amazon Lex V2 console or SDK. The capability is available in all AWS Regions where Amazon Lex operates in the English (Australia), English (UK), and English (US) locales.<\/p>\n
              To learn more, refer to Using a custom grammar slot type<\/a>.<\/p>\n
              \n
              About the Authors<\/h3>\n
              \"\"<\/a>John Heater<\/strong> has over 15 years of experience in AI and automation. As the SVP of the Contact Center Practice at NeuraFlash, he leads the implementation of the latest AI and automation techniques for a portfolio of products and customer solutions.<\/p>\n
              \"\"<\/a>Sandeep Srinivasan<\/strong> is a Product Manager on the Amazon Lex team. As a keen observer of human behavior, he is passionate about customer experience. He spends his waking hours at the intersection of people, technology, and the future.<\/p>\n
                     \n      <\/div>\n","protected":false},"excerpt":{"rendered":"
              https:\/\/aws.amazon.com\/blogs\/machine-learning\/expedite-ivr-development-with-industry-grammars-on-amazon-lex\/<\/p>\n","protected":false},"author":0,"featured_media":2005,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[3],"tags":[],"_links":{"self":[{"href":"https:\/\/salarydistribution.com\/machine-learning\/wp-json\/wp\/v2\/posts\/2004"}],"collection":[{"href":"https:\/\/salarydistribution.com\/machine-learning\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/salarydistribution.com\/machine-learning\/wp-json\/wp\/v2\/types\/post"}],"replies":[{"embeddable":true,"href":"https:\/\/salarydistribution.com\/machine-learning\/wp-json\/wp\/v2\/comments?post=2004"}],"version-history":[{"count":0,"href":"https:\/\/salarydistribution.com\/machine-learning\/wp-json\/wp\/v2\/posts\/2004\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/salarydistribution.com\/machine-learning\/wp-json\/wp\/v2\/media\/2005"}],"wp:attachment":[{"href":"https:\/\/salarydistribution.com\/machine-learning\/wp-json\/wp\/v2\/media?parent=2004"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/salarydistribution.com\/machine-learning\/wp-json\/wp\/v2\/categories?post=2004"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/salarydistribution.com\/machine-learning\/wp-json\/wp\/v2\/tags?post=2004"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}