{
  "id": 432501,
  "title": "is tensorflow beam search  ops supported in TFlite?",
  "url": "/competitions/asl-fingerspelling/discussion/432501",
  "author_name": "hengck23",
  "post_date": "2023-08-17T17:41:50.995000",
  "votes": 6,
  "comment_count": 10,
  "views": 0,
  "content": "<p><img src=\"https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F113660%2Fb1527785368ea4119c96a46bbb9626f6%2FSelection_999(2930).png?generation=1692293983013869&amp;alt=media\" alt=\"\"></p>\n<p>TF ops were not allowed in the previous ASL competition. <br>\nI want to confirm if it is allowed in this competition. I had submission error when trying  raw_ops.CTCBeamSearchDecoder.</p>\n<p>Thanks</p>",
  "messages": [
    {
      "id": 2395643,
      "postDate": "2023-08-17T17:41:50.997Z",
      "content": "<p><img src=\"https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F113660%2Fb1527785368ea4119c96a46bbb9626f6%2FSelection_999(2930).png?generation=1692293983013869&amp;alt=media\" alt=\"\"></p>\n<p>TF ops were not allowed in the previous ASL competition. <br>\nI want to confirm if it is allowed in this competition. I had submission error when trying  raw_ops.CTCBeamSearchDecoder.</p>\n<p>Thanks</p>",
      "rawMarkdown": "![](https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F113660%2Fb1527785368ea4119c96a46bbb9626f6%2FSelection_999(2930).png?generation=1692293983013869&alt=media)\n\nTF ops were not allowed in the previous ASL competition. \nI want to confirm if it is allowed in this competition. I had submission error when trying  raw_ops.CTCBeamSearchDecoder.\n\nThanks",
      "votes": 6
    },
    {
      "id": 2401453,
      "postDate": "2023-08-21T15:46:59.260Z",
      "content": "<p>some pointer, <br>\n<a href=\"https://keras.io/api/keras_nlp/utils/beam_search/\" target=\"_blank\">https://keras.io/api/keras_nlp/utils/beam_search/</a></p>",
      "rawMarkdown": "some pointer, \nhttps://keras.io/api/keras_nlp/utils/beam_search/",
      "votes": 1
    },
    {
      "id": 2395648,
      "postDate": "2023-08-17T17:43:27.223Z",
      "content": "<p>It doesn't seem to be supported, so you'd have to write a custom implementation yourself.</p>",
      "rawMarkdown": "It doesn't seem to be supported, so you'd have to write a custom implementation yourself.",
      "votes": 1,
      "replies": [
        {
          "id": 2396098,
          "postDate": "2023-08-18T04:11:33.907Z",
          "content": "<p>thanks.</p>\n<p>probably one of the simplest implementation for those whoa re interested<br>\n<a href=\"https://gist.github.com/chao-ji/9ecc17adff1a8793b556f42ffb6a5b19\" target=\"_blank\">https://gist.github.com/chao-ji/9ecc17adff1a8793b556f42ffb6a5b19</a></p>\n<p>tflite support hash tables, which can be used for transitional probability </p>",
          "rawMarkdown": "thanks.\n\nprobably one of the simplest implementation for those whoa re interested\nhttps://gist.github.com/chao-ji/9ecc17adff1a8793b556f42ffb6a5b19\n\ntflite support hash tables, which can be used for transitional probability ",
          "votes": 2,
          "replies": [
            {
              "id": 2397102,
              "postDate": "2023-08-18T17:59:40.693Z",
              "content": "<blockquote>\n  <p>thanks.</p>\n  <p>probably one of the simplest implementation for those whoa re interested<br>\n  <a href=\"https://gist.github.com/chao-ji/9ecc17adff1a8793b556f42ffb6a5b19\" target=\"_blank\">https://gist.github.com/chao-ji/9ecc17adff1a8793b556f42ffb6a5b19</a></p>\n  <p>tflite support hash tables, which can be used for transitional probability</p>\n</blockquote>\n<p>Nice! Here's mine, which is about 6 times shorter and less convoluted. Good luck implementing this in TFLite though… </p>\n<pre><code>import numpy as np\nimport time\n\ndef beam_search(mat):\n    \n    print(mat.shape)\n    beam_width = 5\n    step1_times = \n    step2_times = \n    step3_times = \n    step4_times = \n\n\n    blank_idx = len(chars)\n    max_T, max_C = mat.shape\n    blank_idx = max_C - 1\n    last_chars_map = np.arange(max_C - 1)\n\n    # initialise beam state\n    labels = \n    pr_blanks = np.array()\n    pr_totals = np.array()\n    pr_non_blanks = np.array()\n\n    new_pr_blanks = np.zeros((beam_width * (len(chars) + 1)))\n    new_pr_totals = np.zeros((beam_width * (len(chars) + 1)))\n    new_pr_non_blanks = np.zeros((beam_width * (len(chars) + 1)))\n\n    # go over all time-steps\n    for t in range(0, max_T):\n        # get beam-labelings  best beams\n        if len(labels) &lt;= beam_width:\n            ixs = np.arange(len(labels))\n        else:\n            ixs = np.argpartition(pr_totals, -beam_width)\n\n        new_labels = \n\n        # go over best beams\n        stored_ixs = \n        for j, ix in enumerate(ixs):\n            # probability  paths ending with a non-blank\n            pr_non_blank = 0\n            # in case  non-empty beam\n            if len(labels) &gt; 0:\n                # probability  paths with repeated last char at the end\n                pr_non_blank = pr_non_blanks * mat\n\n            # probability  paths ending with a blank\n            pr_blank = pr_totals * mat\n\n            # fill in data for current beam\n            new_labels.append(labels)\n            new_pr_non_blanks = pr_non_blank\n            new_pr_blanks = pr_blank\n            new_pr_totals = pr_blank + pr_non_blank\n\n            new_labeling = \n\n            pr_non_blank = pr_totals * mat\n            if len(labels) &gt; 0:\n                pr_non_blank = pr_blanks * mat\n\n            new_labels += new_labeling\n            new_pr_non_blanks = pr_non_blank\n            new_pr_totals = pr_non_blank\n            new_pr_blanks = 0\n\n        unique_labels, inverse = np.unique(new_labels, return_inverse=True, axis=0)\n        label_count = unique_labels.shape\n\n        pr_blanks = np.zeros(label_count)\n        pr_totals = np.zeros(label_count)\n        pr_non_blanks = np.zeros(label_count)\n\n        np.add.at(pr_blanks, inverse, new_pr_blanks)\n        np.add.at(pr_totals, inverse, new_pr_totals)\n        np.add.at(pr_non_blanks, inverse, new_pr_non_blanks)\n\n        labels = np.array()\n\n    # sort by probability\n    best_labeling = labels\n\n    # map label string to char string\n    return np.array(, dtype=np.int64)\n    return best_labeling\n</code></pre>",
              "rawMarkdown": "> thanks.\n> \n> probably one of the simplest implementation for those whoa re interested\n> https://gist.github.com/chao-ji/9ecc17adff1a8793b556f42ffb6a5b19\n> \n> tflite support hash tables, which can be used for transitional probability\n\nNice! Here's mine, which is about 6 times shorter and less convoluted. Good luck implementing this in TFLite though... \n\n```\nimport numpy as np\nimport time\n\ndef beam_search(mat):\n    \"\"\"Beam search decoder.\n\n    See the paper of Hwang et al. and the paper of Graves et al.\n\n    Args:\n        mat: Output of neural network of shape TxC.\n        chars: The set of characters the neural network can recognize, excluding the CTC-blank.\n        beam_width: Number of beams kept per iteration.\n        lm: Character level language model if specified.\n\n    Returns:\n        The decoded text.\n    \"\"\"\n    print(mat.shape)\n    beam_width = 5\n    step1_times = []\n    step2_times = []\n    step3_times = []\n    step4_times = []\n    \n    \n    blank_idx = len(chars)\n    max_T, max_C = mat.shape\n    blank_idx = max_C - 1\n    last_chars_map = np.arange(max_C - 1)\n\n    # initialise beam state\n    labels = ['']\n    pr_blanks = np.array([1])\n    pr_totals = np.array([1])\n    pr_non_blanks = np.array([0])\n\n    new_pr_blanks = np.zeros((beam_width * (len(chars) + 1)))\n    new_pr_totals = np.zeros((beam_width * (len(chars) + 1)))\n    new_pr_non_blanks = np.zeros((beam_width * (len(chars) + 1)))\n    \n    # go over all time-steps\n    for t in range(0, max_T):\n        # get beam-labelings of best beams\n        if len(labels) <= beam_width:\n            ixs = np.arange(len(labels))\n        else:\n            ixs = np.argpartition(pr_totals, -beam_width)[-beam_width:]\n        \n        new_labels = []\n        \n        # go over best beams\n        stored_ixs = []\n        for j, ix in enumerate(ixs):\n            # probability of paths ending with a non-blank\n            pr_non_blank = 0\n            # in case of non-empty beam\n            if len(labels[ix]) > 0:\n                # probability of paths with repeated last char at the end\n                pr_non_blank = pr_non_blanks[ix] * mat[t, mapping[labels[ix][-1]]]\n                \n            # probability of paths ending with a blank\n            pr_blank = pr_totals[ix] * mat[t, blank_idx]\n            \n            # fill in data for current beam\n            new_labels.append(labels[ix])\n            new_pr_non_blanks[j * max_C] = pr_non_blank\n            new_pr_blanks[j * max_C] = pr_blank\n            new_pr_totals[j * max_C] = pr_blank + pr_non_blank\n            \n            new_labeling = [labels[ix] + rev_mapping[c] for c in range(max_C - 1)]\n            \n            pr_non_blank = pr_totals[ix] * mat[t, last_chars_map]\n            if len(labels[ix]) > 0:\n                pr_non_blank[mapping[labels[ix][-1]]] = pr_blanks[ix] * mat[t, mapping[labels[ix][-1]]]\n                \n            new_labels += new_labeling\n            new_pr_non_blanks[j * max_C + 1:(j + 1) * max_C] = pr_non_blank\n            new_pr_totals[j * max_C + 1:(j + 1) * max_C] = pr_non_blank\n            new_pr_blanks[j * max_C + 1:(j + 1) * max_C] = 0\n\n        unique_labels, inverse = np.unique(new_labels, return_inverse=True, axis=0)\n        label_count = unique_labels.shape[0]\n\n        pr_blanks = np.zeros(label_count)\n        pr_totals = np.zeros(label_count)\n        pr_non_blanks = np.zeros(label_count)\n\n        np.add.at(pr_blanks, inverse, new_pr_blanks[:len(new_labels)])\n        np.add.at(pr_totals, inverse, new_pr_totals[:len(new_labels)])\n        np.add.at(pr_non_blanks, inverse, new_pr_non_blanks[:len(new_labels)])\n\n        labels = np.array([label for label in unique_labels])\n\n    # sort by probability\n    best_labeling = labels[np.argmax(pr_totals)]\n\n    # map label string to char string\n    return np.array([mapping[c] for c in best_labeling], dtype=np.int64)\n    return best_labeling\n```",
              "votes": 4
            },
            {
              "id": 2399626,
              "postDate": "2023-08-20T13:50:55.350Z",
              "content": "<p>thanks a lot!</p>\n<p>i end up training ngram-CTC instead. i.e. groups some of the common token like \"www.\" \".com\" … as single unit.</p>\n<p>time is running out for me !!!!</p>",
              "rawMarkdown": "thanks a lot!\n\ni end up training ngram-CTC instead. i.e. groups some of the common token like \"www.\" \".com\" ... as single unit.\n\ntime is running out for me !!!!",
              "votes": 2
            },
            {
              "id": 2402075,
              "postDate": "2023-08-22T02:02:29.157Z",
              "content": "<p>Seems not work correctly….</p>",
              "rawMarkdown": "Seems not work correctly...."
            },
            {
              "id": 2402113,
              "postDate": "2023-08-22T02:26:12.800Z",
              "content": "<p>i am referencing:<br>\n<a href=\"https://arxiv.org/pdf/1703.00096.pdf\" target=\"_blank\">https://arxiv.org/pdf/1703.00096.pdf</a></p>\n<ul>\n<li>Gram-CTC: Automatic Unit Selection and Target Decomposition for Sequence Labelling<br>\n-code: <a href=\"https://github.com/musyoku/chainer-gram-ctc\" target=\"_blank\">https://github.com/musyoku/chainer-gram-ctc</a></li>\n</ul>\n<p>there is some improvement, but not as much as i hoped.</p>\n<p>note:</p>\n<pre><code>truth=www.xxx.com\n\nCTC predict : ______.__  \ngramCTC predict : _____ww&lt;www.&gt;.___  \n</code></pre>\n<hr>\n<p>you need estimate the upper bound for accuracy improvement for ngram modeling.<br>\nthe simplest way is to:</p>\n<ul>\n<li>consider url phrase (split into words by .,slash, hypen, @ )</li>\n<li>consider address phrase (split into words by space)</li>\n</ul>\n<p>then use kenLM to build an language model as see if CTC+LM is better than CTC.<br>\nThe limit of CTC variants should be around  CTC+LM</p>\n<p>if you are using pytorch, it would be easy to do these</p>\n<hr>\n<p>there is also<br>\nBERT Meets CTC: New Formulation of End-to-End Speech<br>\n<a href=\"https://arxiv.org/abs/2210.16663\" target=\"_blank\">https://arxiv.org/abs/2210.16663</a></p>\n<p>and if you check NEMO ASR tookit, it is CTC with BPE token as ouput<br>\n(another good estimation for upper bound improvement)</p>\n<hr>\n<p>finally there is rnnt which is kinda of </p>\n<pre><code>___&lt; of  or &gt;_&lt; of  or &gt;___\n</code></pre>",
              "rawMarkdown": "i am referencing:\nhttps://arxiv.org/pdf/1703.00096.pdf\n- Gram-CTC: Automatic Unit Selection and Target Decomposition for Sequence Labelling\n-code: https://github.com/musyoku/chainer-gram-ctc\n\nthere is some improvement, but not as much as i hoped.\n\nnote:\n\n```\ntruth=www.xxx.com\n\nCTC predict : ___ww_ww_w___.__  --> collapse = www.\ngramCTC predict : __w___ww<www.>.___  --> collapse = www.\n\n```\n\n---\nyou need estimate the upper bound for accuracy improvement for ngram modeling.\nthe simplest way is to:\n- consider url phrase (split into words by .,slash, hypen, @ )\n- consider address phrase (split into words by space)\n\nthen use kenLM to build an language model as see if CTC+LM is better than CTC.\nThe limit of CTC variants should be around  CTC+LM\n\nif you are using pytorch, it would be easy to do these\n\n---\nthere is also\nBERT Meets CTC: New Formulation of End-to-End Speech\nhttps://arxiv.org/abs/2210.16663\n\nand if you check NEMO ASR tookit, it is CTC with BPE token as ouput\n(another good estimation for upper bound improvement)\n\n---\nfinally there is rnnt which is kinda of \n```\n___<group of char or char>_<group of char or char>___\n```\n\n",
              "votes": 1
            }
          ]
        }
      ]
    },
    {
      "id": 2400719,
      "postDate": "2023-08-21T07:45:32.817Z",
      "rawMarkdown": "",
      "isDeleted": true,
      "replies": [
        {
          "id": 2400743,
          "postDate": "2023-08-21T08:01:53.823Z",
          "content": "<p>you have to rewrite everything in tf functions, beam search is too slow for me, so i have to try alternatives</p>",
          "rawMarkdown": "you have to rewrite everything in tf functions, beam search is too slow for me, so i have to try alternatives",
          "votes": 1,
          "replies": [
            {
              "id": 2400751,
              "postDate": "2023-08-21T08:06:39.183Z",
              "content": "<p>yes. I just realized a full rewriting is the only solution. thanks</p>",
              "rawMarkdown": "yes. I just realized a full rewriting is the only solution. thanks"
            }
          ]
        }
      ]
    }
  ],
  "comments": [
    {
      "id": 2401453,
      "author_name": "Innat",
      "author_url": "",
      "post_date": "2023-08-21T15:46:59.260000",
      "content": "<p>some pointer, <br>\n<a href=\"https://keras.io/api/keras_nlp/utils/beam_search/\" target=\"_blank\">https://keras.io/api/keras_nlp/utils/beam_search/</a></p>",
      "votes": 1,
      "replies": []
    },
    {
      "id": 2395648,
      "author_name": "Gilles Vandewiele",
      "author_url": "",
      "post_date": "2023-08-17T17:43:27.223000",
      "content": "<p>It doesn't seem to be supported, so you'd have to write a custom implementation yourself.</p>",
      "votes": 1,
      "replies": [
        {
          "id": 2396098,
          "author_name": "hengck23",
          "author_url": "",
          "post_date": "2023-08-18T04:11:33.907000",
          "content": "<p>thanks.</p>\n<p>probably one of the simplest implementation for those whoa re interested<br>\n<a href=\"https://gist.github.com/chao-ji/9ecc17adff1a8793b556f42ffb6a5b19\" target=\"_blank\">https://gist.github.com/chao-ji/9ecc17adff1a8793b556f42ffb6a5b19</a></p>\n<p>tflite support hash tables, which can be used for transitional probability </p>",
          "votes": 2,
          "replies": [
            {
              "id": 2397102,
              "author_name": "Gilles Vandewiele",
              "author_url": "",
              "post_date": "2023-08-18T17:59:40.693000",
              "content": "<blockquote>\n  <p>thanks.</p>\n  <p>probably one of the simplest implementation for those whoa re interested<br>\n  <a href=\"https://gist.github.com/chao-ji/9ecc17adff1a8793b556f42ffb6a5b19\" target=\"_blank\">https://gist.github.com/chao-ji/9ecc17adff1a8793b556f42ffb6a5b19</a></p>\n  <p>tflite support hash tables, which can be used for transitional probability</p>\n</blockquote>\n<p>Nice! Here's mine, which is about 6 times shorter and less convoluted. Good luck implementing this in TFLite though… </p>\n<pre><code>import numpy as np\nimport time\n\ndef beam_search(mat):\n    \n    print(mat.shape)\n    beam_width = 5\n    step1_times = \n    step2_times = \n    step3_times = \n    step4_times = \n\n\n    blank_idx = len(chars)\n    max_T, max_C = mat.shape\n    blank_idx = max_C - 1\n    last_chars_map = np.arange(max_C - 1)\n\n    # initialise beam state\n    labels = \n    pr_blanks = np.array()\n    pr_totals = np.array()\n    pr_non_blanks = np.array()\n\n    new_pr_blanks = np.zeros((beam_width * (len(chars) + 1)))\n    new_pr_totals = np.zeros((beam_width * (len(chars) + 1)))\n    new_pr_non_blanks = np.zeros((beam_width * (len(chars) + 1)))\n\n    # go over all time-steps\n    for t in range(0, max_T):\n        # get beam-labelings  best beams\n        if len(labels) &lt;= beam_width:\n            ixs = np.arange(len(labels))\n        else:\n            ixs = np.argpartition(pr_totals, -beam_width)\n\n        new_labels = \n\n        # go over best beams\n        stored_ixs = \n        for j, ix in enumerate(ixs):\n            # probability  paths ending with a non-blank\n            pr_non_blank = 0\n            # in case  non-empty beam\n            if len(labels) &gt; 0:\n                # probability  paths with repeated last char at the end\n                pr_non_blank = pr_non_blanks * mat\n\n            # probability  paths ending with a blank\n            pr_blank = pr_totals * mat\n\n            # fill in data for current beam\n            new_labels.append(labels)\n            new_pr_non_blanks = pr_non_blank\n            new_pr_blanks = pr_blank\n            new_pr_totals = pr_blank + pr_non_blank\n\n            new_labeling = \n\n            pr_non_blank = pr_totals * mat\n            if len(labels) &gt; 0:\n                pr_non_blank = pr_blanks * mat\n\n            new_labels += new_labeling\n            new_pr_non_blanks = pr_non_blank\n            new_pr_totals = pr_non_blank\n            new_pr_blanks = 0\n\n        unique_labels, inverse = np.unique(new_labels, return_inverse=True, axis=0)\n        label_count = unique_labels.shape\n\n        pr_blanks = np.zeros(label_count)\n        pr_totals = np.zeros(label_count)\n        pr_non_blanks = np.zeros(label_count)\n\n        np.add.at(pr_blanks, inverse, new_pr_blanks)\n        np.add.at(pr_totals, inverse, new_pr_totals)\n        np.add.at(pr_non_blanks, inverse, new_pr_non_blanks)\n\n        labels = np.array()\n\n    # sort by probability\n    best_labeling = labels\n\n    # map label string to char string\n    return np.array(, dtype=np.int64)\n    return best_labeling\n</code></pre>",
              "votes": 4,
              "replies": []
            },
            {
              "id": 2399626,
              "author_name": "hengck23",
              "author_url": "",
              "post_date": "2023-08-20T13:50:55.350000",
              "content": "<p>thanks a lot!</p>\n<p>i end up training ngram-CTC instead. i.e. groups some of the common token like \"www.\" \".com\" … as single unit.</p>\n<p>time is running out for me !!!!</p>",
              "votes": 2,
              "replies": []
            },
            {
              "id": 2402075,
              "author_name": "gezi",
              "author_url": "",
              "post_date": "2023-08-22T02:02:29.157000",
              "content": "<p>Seems not work correctly….</p>",
              "votes": 0,
              "replies": []
            },
            {
              "id": 2402113,
              "author_name": "hengck23",
              "author_url": "",
              "post_date": "2023-08-22T02:26:12.800000",
              "content": "<p>i am referencing:<br>\n<a href=\"https://arxiv.org/pdf/1703.00096.pdf\" target=\"_blank\">https://arxiv.org/pdf/1703.00096.pdf</a></p>\n<ul>\n<li>Gram-CTC: Automatic Unit Selection and Target Decomposition for Sequence Labelling<br>\n-code: <a href=\"https://github.com/musyoku/chainer-gram-ctc\" target=\"_blank\">https://github.com/musyoku/chainer-gram-ctc</a></li>\n</ul>\n<p>there is some improvement, but not as much as i hoped.</p>\n<p>note:</p>\n<pre><code>truth=www.xxx.com\n\nCTC predict : ______.__  \ngramCTC predict : _____ww&lt;www.&gt;.___  \n</code></pre>\n<hr>\n<p>you need estimate the upper bound for accuracy improvement for ngram modeling.<br>\nthe simplest way is to:</p>\n<ul>\n<li>consider url phrase (split into words by .,slash, hypen, @ )</li>\n<li>consider address phrase (split into words by space)</li>\n</ul>\n<p>then use kenLM to build an language model as see if CTC+LM is better than CTC.<br>\nThe limit of CTC variants should be around  CTC+LM</p>\n<p>if you are using pytorch, it would be easy to do these</p>\n<hr>\n<p>there is also<br>\nBERT Meets CTC: New Formulation of End-to-End Speech<br>\n<a href=\"https://arxiv.org/abs/2210.16663\" target=\"_blank\">https://arxiv.org/abs/2210.16663</a></p>\n<p>and if you check NEMO ASR tookit, it is CTC with BPE token as ouput<br>\n(another good estimation for upper bound improvement)</p>\n<hr>\n<p>finally there is rnnt which is kinda of </p>\n<pre><code>___&lt; of  or &gt;_&lt; of  or &gt;___\n</code></pre>",
              "votes": 1,
              "replies": []
            }
          ]
        }
      ]
    },
    {
      "id": 2400719,
      "author_name": "",
      "author_url": "",
      "post_date": "2023-08-21T07:45:32.817000",
      "content": "",
      "votes": 0,
      "replies": [
        {
          "id": 2400743,
          "author_name": "hengck23",
          "author_url": "",
          "post_date": "2023-08-21T08:01:53.823000",
          "content": "<p>you have to rewrite everything in tf functions, beam search is too slow for me, so i have to try alternatives</p>",
          "votes": 1,
          "replies": [
            {
              "id": 2400751,
              "author_name": "mk6",
              "author_url": "",
              "post_date": "2023-08-21T08:06:39.183000",
              "content": "<p>yes. I just realized a full rewriting is the only solution. thanks</p>",
              "votes": 0,
              "replies": []
            }
          ]
        }
      ]
    }
  ],
  "raw_markdown_by_id": {
    "2395643": "![](https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F113660%2Fb1527785368ea4119c96a46bbb9626f6%2FSelection_999(2930).png?generation=1692293983013869&alt=media)\n\nTF ops were not allowed in the previous ASL competition. \nI want to confirm if it is allowed in this competition. I had submission error when trying  raw_ops.CTCBeamSearchDecoder.\n\nThanks",
    "2401453": "some pointer, \nhttps://keras.io/api/keras_nlp/utils/beam_search/",
    "2395648": "It doesn't seem to be supported, so you'd have to write a custom implementation yourself.",
    "2400719": ""
  }
}