{
  "id": 667483,
  "title": "Significant number (up to 25%) of incorrectly truncated texts in train.csv",
  "url": "/competitions/deep-past-initiative-machine-translation/discussion/667483",
  "author_name": "",
  "post_date": "2026-01-12T21:11:17.543455700Z",
  "votes": 14,
  "comment_count": 5,
  "views": 0,
  "content": "<p>Some time ago I posted <a href=\"https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/663849\" target=\"_blank\">a short analysis on how some translations were too short for their corresponding transliterations</a> and more recently <a href=\"https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/664177#3384304\" target=\"_blank\">how insight gained from \"Sentences_Oare_FirstWord_LinNum.csv\" confirmed that the problem</a>.</p>\n<p>The problem became elusive for a lack of good rule to pinpoint the faulty texts, until <a href=\"https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/666745#3388631\" target=\"_blank\">I followed a conversation with Aaron about number allignment</a>.</p>\n<p>When implemented, this yielded around 400 texts, which gives about 25% of total texts from <code>train.csv</code>. That's significant and could impact the performance of the models learning to predict something that is not there.</p>\n<p>The number is not fixed and is strongly dependent on the pattern I used for capturing the consecutive number sequences in transliterations and in translations, then aligning the matches by ID and identifying mismatches.</p>\n<hr>\n<h1>Number sequences in transliterations</h1>\n<pre><code>'((?:\\d+\\.*\\d*)*\\s*(?:(?:ma-na)|GÍN|GÚ|(?:me-at))(?:(?:\\s|\\sù\\s)(?:\\d+\\.*\\d*)\\s(?:(?:ma-na)|GÍN|GÚ))*)'\n</code></pre>\n<p>This captures all sequencess that:</p>\n<ol>\n<li>start with at least a single digit (optionally followed by a dots and digits to account for floating point numbers)</li>\n<li>followed by the quantity-related sequences (ma-na - mina, GÍN - shekel, GÚ - talent, me-at - hundred)</li>\n<li>optionally followed by a sequences (me-at excluded) either whitespace separated or <code>ù</code>-separated (Old Assyrian for <em>and</em>)</li>\n</ol>\n<h1>Number sequence in translations</h1>\n<pre><code>((?:(?:\\d+\\.*\\d*)|(?:(?:\\d+\\s?\\d+)\\s?/\\s?\\d+)|one|two|three|four|five|six|seven|eight|nine|ten)*\\s*(?:(?:mina[s]?)|s[hk]{1}e[hk]{1}el[s]?|talent[s]?))(?:(?:\\s|\\sand\\s|\\sor\\s)(?:(?:\\d+\\.*\\d*)|one|two|three|four|five|six|seven|eight|nine|ten)\\s(?:(?:mina[s]?)|s[hk]{1}e[hk]{1}el[s]?|talent[s]?))*\n</code></pre>\n<p>This works similarly to the transliteration pattern but accounts for more numerals (<em>one</em> up to <em>ten</em>) and typos in the word shekel (sometimes spelled <em>skekel</em>).</p>\n<h1>Word length correlation (translation vs. transliteration)</h1>\n<p>Using the above captures patterns results in matches, which alligned based on the text index give the alignment:\n<img src=\"https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2259646%2F6172f1dd39fc4adf91d4f645676cb3cc%2FNumber%20alignment%20between%20transliterations%20and%20translations%20in%20train.csv.png?generation=1768251784155423&amp;alt=media\" alt=\"\"></p>\n<p>If removed, the correlation between the word lengths (split on whitespace) of transliterations and translations becomes more apparent. The texts have not been cleaned prior to the splitting, which is the source of additional noise. The gaps should be collapsed to <code>&lt;gap&gt;</code> and <code>&lt;big_gap&gt;</code> but I wanted to share some information on raw data first.\n<img src=\"https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2259646%2F05b431e89a56186025427773e469d4a8%2FTranslation%20len%20vs%20transliteration%20len.png?generation=1768251530227407&amp;alt=media\" alt=\"\"></p>\n<p>That and more information is shared in <a href=\"https://www.kaggle.com/code/angantyr/deep-past-2025-data-analysis-and-cleaning\" target=\"_blank\">the analysis notebook</a>.</p>\n<p>Personally I would not remove the texts altogether, since there are already signs and words poorly represented. A clean way to crop the texts at the last matching point could be of potential benefit, though.</p>",
  "messages": [
    {
      "id": "3390256",
      "postDate": "01/12/2026 21:11:17",
      "content": "<p>Some time ago I posted <a href=\"https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/663849\" target=\"_blank\">a short analysis on how some translations were too short for their corresponding transliterations</a> and more recently <a href=\"https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/664177#3384304\" target=\"_blank\">how insight gained from \"Sentences_Oare_FirstWord_LinNum.csv\" confirmed that the problem</a>.</p>\n<p>The problem became elusive for a lack of good rule to pinpoint the faulty texts, until <a href=\"https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/666745#3388631\" target=\"_blank\">I followed a conversation with Aaron about number allignment</a>.</p>\n<p>When implemented, this yielded around 400 texts, which gives about 25% of total texts from <code>train.csv</code>. That's significant and could impact the performance of the models learning to predict something that is not there.</p>\n<p>The number is not fixed and is strongly dependent on the pattern I used for capturing the consecutive number sequences in transliterations and in translations, then aligning the matches by ID and identifying mismatches.</p>\n<hr>\n<h1>Number sequences in transliterations</h1>\n<pre><code>'((?:\\d+\\.*\\d*)*\\s*(?:(?:ma-na)|GÍN|GÚ|(?:me-at))(?:(?:\\s|\\sù\\s)(?:\\d+\\.*\\d*)\\s(?:(?:ma-na)|GÍN|GÚ))*)'\n</code></pre>\n<p>This captures all sequencess that:</p>\n<ol>\n<li>start with at least a single digit (optionally followed by a dots and digits to account for floating point numbers)</li>\n<li>followed by the quantity-related sequences (ma-na - mina, GÍN - shekel, GÚ - talent, me-at - hundred)</li>\n<li>optionally followed by a sequences (me-at excluded) either whitespace separated or <code>ù</code>-separated (Old Assyrian for <em>and</em>)</li>\n</ol>\n<h1>Number sequence in translations</h1>\n<pre><code>((?:(?:\\d+\\.*\\d*)|(?:(?:\\d+\\s?\\d+)\\s?/\\s?\\d+)|one|two|three|four|five|six|seven|eight|nine|ten)*\\s*(?:(?:mina[s]?)|s[hk]{1}e[hk]{1}el[s]?|talent[s]?))(?:(?:\\s|\\sand\\s|\\sor\\s)(?:(?:\\d+\\.*\\d*)|one|two|three|four|five|six|seven|eight|nine|ten)\\s(?:(?:mina[s]?)|s[hk]{1}e[hk]{1}el[s]?|talent[s]?))*\n</code></pre>\n<p>This works similarly to the transliteration pattern but accounts for more numerals (<em>one</em> up to <em>ten</em>) and typos in the word shekel (sometimes spelled <em>skekel</em>).</p>\n<h1>Word length correlation (translation vs. transliteration)</h1>\n<p>Using the above captures patterns results in matches, which alligned based on the text index give the alignment:\n<img src=\"https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2259646%2F6172f1dd39fc4adf91d4f645676cb3cc%2FNumber%20alignment%20between%20transliterations%20and%20translations%20in%20train.csv.png?generation=1768251784155423&amp;alt=media\" alt=\"\"></p>\n<p>If removed, the correlation between the word lengths (split on whitespace) of transliterations and translations becomes more apparent. The texts have not been cleaned prior to the splitting, which is the source of additional noise. The gaps should be collapsed to <code>&lt;gap&gt;</code> and <code>&lt;big_gap&gt;</code> but I wanted to share some information on raw data first.\n<img src=\"https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2259646%2F05b431e89a56186025427773e469d4a8%2FTranslation%20len%20vs%20transliteration%20len.png?generation=1768251530227407&amp;alt=media\" alt=\"\"></p>\n<p>That and more information is shared in <a href=\"https://www.kaggle.com/code/angantyr/deep-past-2025-data-analysis-and-cleaning\" target=\"_blank\">the analysis notebook</a>.</p>\n<p>Personally I would not remove the texts altogether, since there are already signs and words poorly represented. A clean way to crop the texts at the last matching point could be of potential benefit, though.</p>",
      "rawMarkdown": "Some time ago I posted [a short analysis on how some translations were too short for their corresponding transliterations](https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/663849) and more recently [how insight gained from \"Sentences_Oare_FirstWord_LinNum.csv\" confirmed that the problem](https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/664177#3384304).\n\nThe problem became elusive for a lack of good rule to pinpoint the faulty texts, until [I followed a conversation with Aaron about number allignment](https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/666745#3388631).\n\nWhen implemented, this yielded around 400 texts, which gives about 25% of total texts from `train.csv`. That's significant and could impact the performance of the models learning to predict something that is not there.\n\nThe number is not fixed and is strongly dependent on the pattern I used for capturing the consecutive number sequences in transliterations and in translations, then aligning the matches by ID and identifying mismatches.\n\n<hr>\n\n# Number sequences in transliterations\n\n```python\n'((?:\\d+\\.*\\d*)*\\s*(?:(?:ma-na)|GÍN|GÚ|(?:me-at))(?:(?:\\s|\\sù\\s)(?:\\d+\\.*\\d*)\\s(?:(?:ma-na)|GÍN|GÚ))*)'\n```\nThis captures all sequencess that:\n1. start with at least a single digit (optionally followed by a dots and digits to account for floating point numbers)\n2. followed by the quantity-related sequences (ma-na - mina, GÍN - shekel, GÚ - talent, me-at - hundred)\n3. optionally followed by a sequences (me-at excluded) either whitespace separated or ` ù `-separated (Old Assyrian for *and*)\n\n# Number sequence in translations\n\n```python\n((?:(?:\\d+\\.*\\d*)|(?:(?:\\d+\\s?\\d+)\\s?/\\s?\\d+)|one|two|three|four|five|six|seven|eight|nine|ten)*\\s*(?:(?:mina[s]?)|s[hk]{1}e[hk]{1}el[s]?|talent[s]?))(?:(?:\\s|\\sand\\s|\\sor\\s)(?:(?:\\d+\\.*\\d*)|one|two|three|four|five|six|seven|eight|nine|ten)\\s(?:(?:mina[s]?)|s[hk]{1}e[hk]{1}el[s]?|talent[s]?))*\n```\n\nThis works similarly to the transliteration pattern but accounts for more numerals (*one* up to *ten*) and typos in the word shekel (sometimes spelled *skekel*).\n\n# Word length correlation (translation vs. transliteration)\nUsing the above captures patterns results in matches, which alligned based on the text index give the alignment:\n![](https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2259646%2F6172f1dd39fc4adf91d4f645676cb3cc%2FNumber%20alignment%20between%20transliterations%20and%20translations%20in%20train.csv.png?generation=1768251784155423&alt=media)\n\nIf removed, the correlation between the word lengths (split on whitespace) of transliterations and translations becomes more apparent. The texts have not been cleaned prior to the splitting, which is the source of additional noise. The gaps should be collapsed to `<gap>` and `<big_gap>` but I wanted to share some information on raw data first.\n![](https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2259646%2F05b431e89a56186025427773e469d4a8%2FTranslation%20len%20vs%20transliteration%20len.png?generation=1768251530227407&alt=media)\n\nThat and more information is shared in [the analysis notebook](https://www.kaggle.com/code/angantyr/deep-past-2025-data-analysis-and-cleaning).\n\nPersonally I would not remove the texts altogether, since there are already signs and words poorly represented. A clean way to crop the texts at the last matching point could be of potential benefit, though.",
      "votes": null
    },
    {
      "id": "3391850",
      "postDate": "01/15/2026 19:54:14",
      "content": "<p>I'm noticing that the main reason i don't think this is impacting the leaderboard is that everyone seems to be truncating after 512 chars when training on the documents if we want to take advantage of chunking the full text I think approaches like this are going to be important.</p>",
      "rawMarkdown": "I'm noticing that the main reason i don't think this is impacting the leaderboard is that everyone seems to be truncating after 512 chars when training on the documents if we want to take advantage of chunking the full text I think approaches like this are going to be important.",
      "votes": null
    },
    {
      "id": "3391863",
      "postDate": "01/15/2026 20:31:15",
      "content": "<p>100% agree on the chunking. I think the \"necessary\" transliterated texts can be way shorter than 512 chars if one uses things like PN, GN, quantities, etc.</p>",
      "rawMarkdown": "100% agree on the chunking. I think the \"necessary\" transliterated texts can be way shorter than 512 chars if one uses things like PN, GN, quantities, etc.",
      "votes": null
    },
    {
      "id": "3392050",
      "postDate": "01/16/2026 08:20:02",
      "content": "<p>It’s an interesting idea using masking and slot filling to make the model generalize I saw some one try it in another thread though and the model just learned to generate the text PN son of PN. I think the model attention can lose crucial token context if you do that since part of how byT5 learns is by learning latent feature relationships between the input and output characters. If you mask all these terms at once you end up with less  information to learn on. If you’re going to do this approach what I would suggest is applying augmented masking probabilistically on different samples in your batch that way you can try to learn these relationships and let your model generalize better.</p>",
      "rawMarkdown": "It’s an interesting idea using masking and slot filling to make the model generalize I saw some one try it in another thread though and the model just learned to generate the text PN son of PN. I think the model attention can lose crucial token context if you do that since part of how byT5 learns is by learning latent feature relationships between the input and output characters. If you mask all these terms at once you end up with less  information to learn on. If you’re going to do this approach what I would suggest is applying augmented masking probabilistically on different samples in your batch that way you can try to learn these relationships and let your model generalize better.",
      "votes": null
    },
    {
      "id": "3392055",
      "postDate": "01/16/2026 08:35:29",
      "content": "<p>Oh, no, I meant fragmenting the text  and sacrificing the bigger context, i.e.,</p>\n<blockquote>\n  <p><code>Um-ma PN DUMU PN a-na PN &lt;some words&gt; 5 GÍN &lt;some words&gt; 0.3333 ma-na &lt;some words&gt; PN</code></p>\n</blockquote>\n<p>would be separated into:</p>\n<blockquote>\n  <p>[<code>Um-ma PN DUMU PN a-na PN &lt;some words&gt; 5 GÍN</code>, <code>5 GÍN &lt;some words&gt; 0.3333 ma-na</code>, 0.3333 ma-na  PN`]</p>\n</blockquote>\n<p>Every chunk is then translated and stitched together on common and known separators. The more such \"static\" separators are found the smaller the text to translate becomes.</p>",
      "rawMarkdown": "Oh, no, I meant fragmenting the text  and sacrificing the bigger context, i.e.,\n> `Um-ma PN DUMU PN a-na PN <some words> 5 GÍN <some words> 0.3333 ma-na <some words> PN`\n\nwould be separated into:\n> [`Um-ma PN DUMU PN a-na PN <some words> 5 GÍN`, `5 GÍN <some words> 0.3333 ma-na`, 0.3333 ma-na <some words> PN`]\n\nEvery chunk is then translated and stitched together on common and known separators. The more such \"static\" separators are found the smaller the text to translate becomes.",
      "votes": null
    },
    {
      "id": "3392145",
      "postDate": "01/16/2026 10:56:39",
      "content": "<p>I think I understand better, but I’m still a little confused  whether this kind of segmentation will work cleanly because the subject verb object order is different between the two languages. What you’re trying to do is use the core units as segmentation and alignment anchors. You should check out my alignment notebook it has a lot of these ideas.</p>",
      "rawMarkdown": "I think I understand better, but I’m still a little confused  whether this kind of segmentation will work cleanly because the subject verb object order is different between the two languages. What you’re trying to do is use the core units as segmentation and alignment anchors. You should check out my alignment notebook it has a lot of these ideas.",
      "votes": null
    }
  ],
  "comments": [
    {
      "id": 3391850,
      "author_name": "aaronbornstein",
      "author_url": "",
      "post_date": "01/15/2026 19:54:14",
      "content": "<p>I'm noticing that the main reason i don't think this is impacting the leaderboard is that everyone seems to be truncating after 512 chars when training on the documents if we want to take advantage of chunking the full text I think approaches like this are going to be important.</p>",
      "votes": null,
      "replies": [
        {
          "id": 3391863,
          "author_name": "angantyr",
          "author_url": "",
          "post_date": "01/15/2026 20:31:15",
          "content": "<p>100% agree on the chunking. I think the \"necessary\" transliterated texts can be way shorter than 512 chars if one uses things like PN, GN, quantities, etc.</p>",
          "votes": null,
          "replies": [
            {
              "id": 3392050,
              "author_name": "aaronbornstein",
              "author_url": "",
              "post_date": "01/16/2026 08:20:02",
              "content": "<p>It’s an interesting idea using masking and slot filling to make the model generalize I saw some one try it in another thread though and the model just learned to generate the text PN son of PN. I think the model attention can lose crucial token context if you do that since part of how byT5 learns is by learning latent feature relationships between the input and output characters. If you mask all these terms at once you end up with less  information to learn on. If you’re going to do this approach what I would suggest is applying augmented masking probabilistically on different samples in your batch that way you can try to learn these relationships and let your model generalize better.</p>",
              "votes": null,
              "replies": [
                {
                  "id": 3392055,
                  "author_name": "angantyr",
                  "author_url": "",
                  "post_date": "01/16/2026 08:35:29",
                  "content": "<p>Oh, no, I meant fragmenting the text  and sacrificing the bigger context, i.e.,</p>\n<blockquote>\n  <p><code>Um-ma PN DUMU PN a-na PN &lt;some words&gt; 5 GÍN &lt;some words&gt; 0.3333 ma-na &lt;some words&gt; PN</code></p>\n</blockquote>\n<p>would be separated into:</p>\n<blockquote>\n  <p>[<code>Um-ma PN DUMU PN a-na PN &lt;some words&gt; 5 GÍN</code>, <code>5 GÍN &lt;some words&gt; 0.3333 ma-na</code>, 0.3333 ma-na  PN`]</p>\n</blockquote>\n<p>Every chunk is then translated and stitched together on common and known separators. The more such \"static\" separators are found the smaller the text to translate becomes.</p>",
                  "votes": null,
                  "replies": [
                    {
                      "id": 3392145,
                      "author_name": "aaronbornstein",
                      "author_url": "",
                      "post_date": "01/16/2026 10:56:39",
                      "content": "<p>I think I understand better, but I’m still a little confused  whether this kind of segmentation will work cleanly because the subject verb object order is different between the two languages. What you’re trying to do is use the core units as segmentation and alignment anchors. You should check out my alignment notebook it has a lot of these ideas.</p>",
                      "votes": null,
                      "replies": []
                    }
                  ]
                }
              ]
            }
          ]
        }
      ]
    }
  ],
  "raw_markdown_by_id": {
    "3390256": "Some time ago I posted [a short analysis on how some translations were too short for their corresponding transliterations](https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/663849) and more recently [how insight gained from \"Sentences_Oare_FirstWord_LinNum.csv\" confirmed that the problem](https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/664177#3384304).\n\nThe problem became elusive for a lack of good rule to pinpoint the faulty texts, until [I followed a conversation with Aaron about number allignment](https://www.kaggle.com/competitions/deep-past-initiative-machine-translation/discussion/666745#3388631).\n\nWhen implemented, this yielded around 400 texts, which gives about 25% of total texts from `train.csv`. That's significant and could impact the performance of the models learning to predict something that is not there.\n\nThe number is not fixed and is strongly dependent on the pattern I used for capturing the consecutive number sequences in transliterations and in translations, then aligning the matches by ID and identifying mismatches.\n\n<hr>\n\n# Number sequences in transliterations\n\n```python\n'((?:\\d+\\.*\\d*)*\\s*(?:(?:ma-na)|GÍN|GÚ|(?:me-at))(?:(?:\\s|\\sù\\s)(?:\\d+\\.*\\d*)\\s(?:(?:ma-na)|GÍN|GÚ))*)'\n```\nThis captures all sequencess that:\n1. start with at least a single digit (optionally followed by a dots and digits to account for floating point numbers)\n2. followed by the quantity-related sequences (ma-na - mina, GÍN - shekel, GÚ - talent, me-at - hundred)\n3. optionally followed by a sequences (me-at excluded) either whitespace separated or ` ù `-separated (Old Assyrian for *and*)\n\n# Number sequence in translations\n\n```python\n((?:(?:\\d+\\.*\\d*)|(?:(?:\\d+\\s?\\d+)\\s?/\\s?\\d+)|one|two|three|four|five|six|seven|eight|nine|ten)*\\s*(?:(?:mina[s]?)|s[hk]{1}e[hk]{1}el[s]?|talent[s]?))(?:(?:\\s|\\sand\\s|\\sor\\s)(?:(?:\\d+\\.*\\d*)|one|two|three|four|five|six|seven|eight|nine|ten)\\s(?:(?:mina[s]?)|s[hk]{1}e[hk]{1}el[s]?|talent[s]?))*\n```\n\nThis works similarly to the transliteration pattern but accounts for more numerals (*one* up to *ten*) and typos in the word shekel (sometimes spelled *skekel*).\n\n# Word length correlation (translation vs. transliteration)\nUsing the above captures patterns results in matches, which alligned based on the text index give the alignment:\n![](https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2259646%2F6172f1dd39fc4adf91d4f645676cb3cc%2FNumber%20alignment%20between%20transliterations%20and%20translations%20in%20train.csv.png?generation=1768251784155423&alt=media)\n\nIf removed, the correlation between the word lengths (split on whitespace) of transliterations and translations becomes more apparent. The texts have not been cleaned prior to the splitting, which is the source of additional noise. The gaps should be collapsed to `<gap>` and `<big_gap>` but I wanted to share some information on raw data first.\n![](https://www.googleapis.com/download/storage/v1/b/kaggle-forum-message-attachments/o/inbox%2F2259646%2F05b431e89a56186025427773e469d4a8%2FTranslation%20len%20vs%20transliteration%20len.png?generation=1768251530227407&alt=media)\n\nThat and more information is shared in [the analysis notebook](https://www.kaggle.com/code/angantyr/deep-past-2025-data-analysis-and-cleaning).\n\nPersonally I would not remove the texts altogether, since there are already signs and words poorly represented. A clean way to crop the texts at the last matching point could be of potential benefit, though.",
    "3391850": "I'm noticing that the main reason i don't think this is impacting the leaderboard is that everyone seems to be truncating after 512 chars when training on the documents if we want to take advantage of chunking the full text I think approaches like this are going to be important.",
    "3391863": "100% agree on the chunking. I think the \"necessary\" transliterated texts can be way shorter than 512 chars if one uses things like PN, GN, quantities, etc.",
    "3392050": "It’s an interesting idea using masking and slot filling to make the model generalize I saw some one try it in another thread though and the model just learned to generate the text PN son of PN. I think the model attention can lose crucial token context if you do that since part of how byT5 learns is by learning latent feature relationships between the input and output characters. If you mask all these terms at once you end up with less  information to learn on. If you’re going to do this approach what I would suggest is applying augmented masking probabilistically on different samples in your batch that way you can try to learn these relationships and let your model generalize better.",
    "3392055": "Oh, no, I meant fragmenting the text  and sacrificing the bigger context, i.e.,\n> `Um-ma PN DUMU PN a-na PN <some words> 5 GÍN <some words> 0.3333 ma-na <some words> PN`\n\nwould be separated into:\n> [`Um-ma PN DUMU PN a-na PN <some words> 5 GÍN`, `5 GÍN <some words> 0.3333 ma-na`, 0.3333 ma-na <some words> PN`]\n\nEvery chunk is then translated and stitched together on common and known separators. The more such \"static\" separators are found the smaller the text to translate becomes.",
    "3392145": "I think I understand better, but I’m still a little confused  whether this kind of segmentation will work cleanly because the subject verb object order is different between the two languages. What you’re trying to do is use the core units as segmentation and alignment anchors. You should check out my alignment notebook it has a lot of these ideas."
  },
  "source": "meta"
}