[DEV] Add scripts for hallucination detection

README.md

@@ -1,231 +1,121 @@
----
-annotations_creators:
-  - machine-generated
-task_categories:
-  - automatic-speech-recognition
-  - text-to-speech
-language:
-  - en
-  - bg
-  - hr
-  - cs
-  - da
-  - nl
-  - et
-  - fi
-  - fr
-  - de
-  - el
-  - hu
-  - ga
-  - it
-  - lv
-  - lt
-  - mt
-  - pl
-  - pt
-  - ro
-  - sk
-  - sl
-  - es
-  - sv
-language_creators:
-  - found
-modality:
-  - text
-  - audio
-multilinguality:
-  - multilingual
-pretty_name: MOSEL
-license: cc-by-4.0
-tags:
-  - speech
-  - speech-to-text
-  - open-source
-  - whisper
-configs:
-  - config_name: bg
-    data_files:
-      - split: train_voxpopuli
-        path: bg/voxpopuli*
-  - config_name: cs
-    data_files:
-      - split: train_voxpopuli
-        path: cs/voxpopuli*
-  - config_name: da
-    data_files:
-      - split: train_voxpopuli
-        path: da/voxpopuli*
-  - config_name: de
-    data_files:
-      - split: train_voxpopuli
-        path: de/voxpopuli*
-  - config_name: el
-    data_files:
-      - split: train_voxpopuli
-        path: el/voxpopuli*
-  - config_name: en
-    data_files:
-      - split: train_voxpopuli
-        path: en/voxpopuli*
-      - split: train_librilight
-        path: en/librilight*
-  - config_name: es
-    data_files:
-      - split: train_voxpopuli
-        path: es/voxpopuli*
-  - config_name: et
-    data_files:
-      - split: train_voxpopuli
-        path: et/voxpopuli*
-  - config_name: fi
-    data_files:
-      - split: train_voxpopuli
-        path: fi/voxpopuli*
-  - config_name: fr
-    data_files:
-      - split: train_voxpopuli
-        path: fr/voxpopuli*
-  - config_name: hr
-    data_files:
-      - split: train_voxpopuli
-        path: hr/voxpopuli*
-  - config_name: hu
-    data_files:
-      - split: train_voxpopuli
-        path: hu/voxpopuli*
-  - config_name: it
-    data_files:
-      - split: train_voxpopuli
-        path: it/voxpopuli*
-  - config_name: lt
-    data_files:
-      - split: train_voxpopuli
-        path: lt/voxpopuli*
-  - config_name: lv
-    data_files:
-      - split: train_voxpopuli
-        path: lv/voxpopuli*
-  - config_name: mt
-    data_files:
-      - split: train_voxpopuli
-        path: mt/voxpopuli*
-  - config_name: nl
-    data_files:
-      - split: train_voxpopuli
-        path: nl/voxpopuli*
-  - config_name: pl
-    data_files:
-      - split: train_voxpopuli
-        path: pl/voxpopuli*
-  - config_name: pt
-    data_files:
-      - split: train_voxpopuli
-        path: pt/voxpopuli*  
-  - config_name: ro
-    data_files:
-      - split: train_voxpopuli
-        path: ro/voxpopuli*
-  - config_name: sk
-    data_files:
-      - split: train_voxpopuli
-        path: sk/voxpopuli*
-  - config_name: sl
-    data_files:
-      - split: train_voxpopuli
-        path: sl/voxpopuli*
-  - config_name: sv
-    data_files:
-      - split: train_voxpopuli
-        path: sv/voxpopuli*
----
-
-<img src="./mosel-logo-transparent.png" align="center" width="100%">
-
-### Dataset Description, Collection, and Source
-
-The MOSEL corpus is a multilingual dataset collection including up to 950K hours of open-source speech recordings covering the 24 official languages of the European Union. We collect data by surveying labeled and unlabeled speech corpora under open-source compliant licenses.
-In particular, MOSEL includes the automatic transcripts of 441k hours of unlabeled speech from VoxPopuli and LibriLight. The data is transcribed using [Whisper large v3](https://huggingface.co/openai/whisper-large-v3).
-Whisper is released under the OS Apache 2.0 License which allows releasing the generated content under any license. Since LibriLight, differently from VoxPopuli, contains segments longer than Whisper's maximum duration limit of 30sec, we split them into chunks of up to 30sec.
-
-- **Curated by:** Marco Gaido, Sara Papi, Luisa Bentivogli, Alessio Brutti, Mauro Cettolo, Roberto Gretter, Marco Matassoni, Mohamed Nabih, and Matteo Negri
-- **Funded by:** FAIR, Meetween, and CINECA
-- **Shared by:** Fondazione Bruno Kessler
-
-### License
-- CC-BY-4.0
-
-### Dataset Sources
-
-- **Collection Repository:** [MOSEL](https://github.com/hlt-mt/mosel)
-- **Paper:** [MOSEL: 950,000 Hours of Speech Data for Open-Source Speech Foundation Model Training on EU Languages](http://arxiv.org/abs/2410.01036)
-
-## Dataset Structure
-
-### Data Config
-The dataset is split into folders corresponding to the languages using the [2-letters ISO codes](https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes), one for each language. Within each folder, a split for each psuedo-labeled dataset is provided. 
-
-### Data Field
-`id`: alphanumeric identifier for the segment
-
-`language`: extended language (e.g., "english")
-
-`text`: the content of the psuedo label
-
-`hall_repeated_ngrams`: True/False - indicates the repetition of an *n*-gram in `text` for a minimum number of times; for *n* in 1 to 2, the threshold is 4, for *n* in 3 to 5, it is 3 
-
-`hall_long_word`: True/False - indicates the presence of a word of at least 40 characters in `text`
-
-`hall_frequent_single_word`: True/False - indicates that `text` consists of only one word which is the most frequent inside the whole text
-
-## Dataset Statistics (in hours)
-
-| Language (LangID) | Labeled | Unlabeled | Total |
-|--------|--------|--------|-------|
-| Bulgarian (bg)     | 111    | 17609  | 17720 |
-| Croatian (hr)     | 55     | 8106   | 8161  |
-| Czech (cs)     | 591    | 18705  | 19296 |
-| Danish (da)     | 20     | 13600  | 13620 |
-| Dutch (nl)     | 3395   | 19014  | 22409 |
-| English (en)     | 437239 | 84704  | 521943|
-| Estonian (et)     | 60     | 10604  | 10664 |
-| Finnish (fi)     | 64     | 14200  | 14264 |
-| French (fr)     | 26984  | 22896  | 49880 |
-| German (de)     | 9236   | 23228  | 32464 |
-| Greek (el)     | 35     | 17703  | 17738 |
-| Hungarian (hu)     | 189    | 17701  | 17890 |
-| Irish (ga)     | 17     | 0      | 17    |
-| Italian (it)     | 3756   | 21933  | 25689 |
-| Latvian (lv)     | 173    | 13100  | 13273 |
-| Lithuanian (lt)     | 36     | 14400  | 14436 |
-| Maltese (mt)     | 19     | 9100   | 9119  |
-| Polish (pl)     | 510    | 21207  | 21717 |
-| Portuguese (pt)     | 5492   | 17526  | 23018 |
-| Romanian (ro)     | 121    | 17906  | 18021 |
-| Slovak (sk)     | 61     | 12100  | 12161 |
-| Slovenian (sl)     | 32     | 11300  | 11332 |
-| Spanish (es)     | 17471  | 21526  | 38997 |
-| Swedish (sv)     | 58     | 16300  | 16358 |
-| Total  | 505725 | 444467 | 950192|
-
-
-## Dataset Creation
-To reproduce the dataset creation, please refer to the [MOSEL README in the fbk-llm](https://github.com/hlt-mt/fbk-llm) repository.
-
-
-## Citation
-Release 1.0:
-```
-@inproceedings{mosel,
-  title = {{MOSEL: 950,000 Hours of Speech Data for Open-Source Speech Foundation Model Training on EU Languages}},
-  author = {Marco Gaido and Sara Papi and Luisa Bentivogli and Alessio Brutti and Mauro Cettolo and Roberto Gretter and Marco Matassoni and Mohamed Nabihand Matteo Negri},
-  booktitle = "Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing",
-  month = nov,
-  year = "2024",
-  address = "Miami, United States",
-  publisher = "Association for Computational Linguistics",
-}
-```
-
-## Dataset Card Contact
-[@spapi](https://huggingface.co/spapi)
+---
+task_categories:
+- automatic-speech-recognition
+language:
+- en
+- bg
+- hr
+- cs
+- da
+- nl
+- et
+- fi
+- fr
+- de
+- el
+- hu
+- ga
+- it
+- lv
+- lt
+- mt
+- pl
+- pt
+- ro
+- sk
+- sl
+- es
+- sv
+pretty_name: MOSEL
+license: cc-by-4.0
+---
+
+<img src="./mosel-logo-transparent.png" align="center" width="100%">
+
+### Dataset Description, Collection, and Source
+
+The MOSEL corpus is a multilingual dataset collection including up to 950K hours of open-source speech recordings covering the 24 official languages of the European Union. We collect data by surveying labeled and unlabeled speech corpora under open-source compliant licenses.
+In particular, MOSEL includes the automatic transcripts of 441k hours of unlabeled speech from VoxPopuli and LibriLight. The data is transcribed using [Whisper large v3](https://huggingface.co/openai/whisper-large-v3).
+Whisper is released under the OS Apache 2.0 License which allows releasing the generated content under any license. Since LibriLight, differently from VoxPopuli, contains segments longer than Whisper's maximum duration limit of 30sec, we split them into chunks of up to 30sec.
+
+- **Curated by:** Marco Gaido, Sara Papi, Luisa Bentivogli, Alessio Brutti, Mauro Cettolo, Roberto Gretter, Marco Matassoni, Mohamed Nabih, and Matteo Negri
+- **Funded by:** FAIR, Meetween, and CINECA
+- **Shared by:** Fondazione Bruno Kessler
+
+### License
+- CC-BY-4.0
+
+### Dataset Sources
+
+- **Collection Repository:** [MOSEL](https://github.com/hlt-mt/mosel)
+- **Paper:** [MOSEL: 950,000 Hours of Speech Data for Open-Source Speech Foundation Model Training on EU Languages](https://arxiv.org/)
+
+## Dataset Structure
+
+### Data Config
+The dataset is split into folders corresponding to the languages using the [2-letters ISO codes](https://en.wikipedia.org/wiki/List_of_ISO_639_language_codes), one for each language. Within each folder, a split for each psuedo-labeled dataset is provided. 
+
+### Data Field
+`id`: alphanumeric identifier for the segment
+
+`language`: extended language (e.g., "english")
+
+`text`: the content of the psuedo label
+
+`hall_repeated_ngrams`: True/False - indicates the repetition of an *n*-gram in `text` for a minimum number of times; for *n* in 1 to 2, the threshold is 4, for *n* in 3 to 5, it is 3 
+
+`hall_long_word`: True/False - indicates the presence of a word of at least 40 characters in `text`
+
+`hall_frequent_single_word`: True/False - indicates that `text` consists of only one word which is the most frequent inside the whole text
+
+## Dataset Statistics (in hours)
+
+| Language (LangID) | Labeled | Unlabeled | Total |
+|--------|--------|--------|-------|
+| Bulgarian (bg)     | 111    | 17609  | 17720 |
+| Croatian (hr)     | 55     | 8106   | 8161  |
+| Czech (cs)     | 591    | 18705  | 19296 |
+| Danish (da)     | 20     | 13600  | 13620 |
+| Dutch (nl)     | 3395   | 19014  | 22409 |
+| English (en)     | 437239 | 84704  | 521943|
+| Estonian (et)     | 60     | 10604  | 10664 |
+| Finnish (fi)     | 64     | 14200  | 14264 |
+| French (fr)     | 26984  | 22896  | 49880 |
+| German (de)     | 9236   | 23228  | 32464 |
+| Greek (el)     | 35     | 17703  | 17738 |
+| Hungarian (hu)     | 189    | 17701  | 17890 |
+| Irish (ga)     | 17     | 0      | 17    |
+| Italian (it)     | 3756   | 21933  | 25689 |
+| Latvian (lv)     | 173    | 13100  | 13273 |
+| Lithuanian (lt)     | 36     | 14400  | 14436 |
+| Maltese (mt)     | 19     | 9100   | 9119  |
+| Polish (pl)     | 510    | 21207  | 21717 |
+| Portuguese (pt)     | 5492   | 17526  | 23018 |
+| Romanian (ro)     | 121    | 17906  | 18021 |
+| Slovak (sk)     | 61     | 12100  | 12161 |
+| Slovenian (sl)     | 32     | 11300  | 11332 |
+| Spanish (es)     | 17471  | 21526  | 38997 |
+| Swedish (sv)     | 58     | 16300  | 16358 |
+| Total  | 505725 | 444467 | 950192|
+
+
+## Dataset Creation
+To reproduce the dataset creation, please refer to the [MOSEL README in the fbk-llm](https://github.com/hlt-mt/fbk-llm) repository.
+The scripts used for hallucination detection are availabe in the `scripts` folder of this repository.
+
+## Citation
+Release 1.0:
+```
+@inproceedings{mosel,
+  title = {{MOSEL: 950,000 Hours of Speech Data for Open-Source Speech Foundation Model Training on EU Languages}},
+  author = {Marco Gaido and Sara Papi and Luisa Bentivogli and Alessio Brutti and Mauro Cettolo and Roberto Gretter and Marco Matassoni and Mohamed Nabihand Matteo Negri},
+  booktitle = "Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing",
+  month = nov,
+  year = "2024",
+  address = "Miami, United States",
+  publisher = "Association for Computational Linguistics",
+}
+```
+
+## Dataset Card Contact
+[@spapi](https://huggingface.co/spapi)

scripts/README.md

@@ -0,0 +1,85 @@
+# Mosel: scripts for flagging hallucinated text
+
+#### Last update: 1 Oct 2024
+
+### Overview
+
+In order to automatically decide whether transcriptions of audio documents generated automatically are reliable, and therefore useful for training, or not, and therefore to be discarded, we focused on the detection of *hallucinations*. In general, “Hallucination in the context of LLMs refers to the generation of text that is erroneous, nonsensical, or detached from reality”. Here, referring to surface hallucinations we consider the subset of the phenomenon which refer to anomalies of the text, disregarding hallucinations related to contents. In fact, it happens that pre-trained LLMs generate **anomalous repetitions** of the same pattern, like (real examples):
+
+- Hey, hey, hey, here, hey.
+- No, no, no, no, no, no, no, no.
+
+or output **very long** and noisy **strings**:
+
+- T-J-N-D-F-Z-3-2-8-W-M-L-G-0-Z-P-O-2-M-2-M-M-O-G-W.
+
+or still produce **single word lines** using a common token but a suspiciously high number of times. For each of the three types of hallucinations a specific script has been designed, whose usage is listed in the following:
+
+```
+flagHallucinations.py
+  -h, --help            show this help message and exit
+  --tsv-InFile TSV_INFILE, -i TSV_INFILE
+                        The input TSV file [Mandatory]
+  --tsv-OutFile TSV_OUTFILE, -o TSV_OUTFILE
+                        The output TSV file [Mandatory. If equal to input TSV
+                        file, the new column is added to the original file]
+  --column COLUMN, -c COLUMN
+                        Column name of the text to process [Optional]
+                        (default: source)
+  --thresh1grams THRESH1GRAMS, -u THRESH1GRAMS
+                        Threshold for 1-2_word hallucinations [Optional]
+                        (default: 4)
+  --threshNgrams THRESHNGRAMS, -n THRESHNGRAMS
+                        Threshold for 3-5_word hallucinations [Optional]
+                        (default: 2)
+  --quiet, -q           Print only True/False, no explanation for True's
+  --version, -v         Print version of the script and exit
+
+```
+```
+flagAnomalousStrings.py
+  -h, --help            show this help message and exit
+  --tsv-InFile TSV_INFILE, -i TSV_INFILE
+                        The input TSV file [Mandatory]
+  --tsv-OutFile TSV_OUTFILE, -o TSV_OUTFILE
+                        The output TSV file [Mandatory. If equal to input TSV
+                        file, the new column is added to the original file]
+  --column COLUMN, -c COLUMN
+                        Column name of the text to process [Optional]
+                        (default: source)
+  --thresh THRESH, -t THRESH
+                        Max number of chars of a string to be unflagged
+                        [Optional] (default: 40)
+  --quiet, -q           Print only True/False, no explanation for True's
+  --version, -v         Print version of the script and exit
+```
+
+```
+flagSuspiciousSingleWord.py
+  -h, --help            show this help message and exit
+  --tsv-InFile TSV_INFILE, -i TSV_INFILE
+                        The input TSV file [Mandatory]
+  --tsv-OutFile TSV_OUTFILE, -o TSV_OUTFILE
+                        The output TSV file [Mandatory. If equal to input TSV
+                        file, the new column ('suspicious single word') is
+                        added to the original file]
+  --tsv-SuspiciousWordFiles TSV_SUSPICIOUSWORDFILES [TSV_SUSPICIOUSWORDFILES ...], -s TSV_SUSPICIOUSWORDFILES [TSV_SUSPICIOUSWORDFILES ...]
+                        The TSV file(s) used to look for the suspicious word
+                        [Optional. If not present, the input TSV file is used
+                        instead]
+  --column COLUMN, -c COLUMN
+                        Column name of the text to process [Optional]
+                        (default: source)
+  --suspiciousWord SUSPICIOUSWORD, -w SUSPICIOUSWORD
+                        suspicious word [if not specified, found in other TSV
+                        files passed as parameters]
+  --quiet, -q           Print only True/False, no explanation for True's
+  --version, -v         Print version of the script and exit
+```
+
+All of them read a TSV file from input (-i) which is expected to include a column (-c) with the text to process; they output a TSV file (-o) with an additional column flagging the specific hallucination each script looks for. If input and output files are the same, the former is replaced by the latter. The -q option suppresses the verbosity on hallucinations that have been found.<br>
+Here the processing carried out by the three scripts:
+- **flagHallucinations.py** It flags (by setting True the corresponding entry of the *hall_repeated_ngrams* column) those sentences where a pattern (*n*-gram, that is a sequence of *n* words) is repeated at least a given number of times; for patterns of size 1 to 2, the minimum number of times for flagging it is set by the thresh1grams parameter (default value: 4), for those of size 3-5 by threshNgrams (2). 
+- **flagAnomalousStrings.py** It flags (by setting True the corresponding entry of the *hall_long_word* column) those sentences where at least one word is abnormally long; the abnormality is set through the thresh parameter, whose default value is 40.
+- **flagSuspiciousSingleWord.py** It flags (by setting True the corresponding entry of the *hall_frequent_single_word*) those sentences which consists of only one single suspicious word. This word can be either passed as a parameter (*suspiciousWord* option) or found inside the TSV input files. In the latter case, it is set as the most frequent word in the text included in files to be inspected. The TSV files to inspect can be passed through the *tsv-SuspiciousWordFiles* option. If no explicit *suspiciousWord* nor *tsv-SuspiciousWordFiles* is passed, the *tsv-InFile* is inspected.
+

scripts/flagAnomalousStrings.py

@@ -0,0 +1,117 @@
+# Copyright 2024 FBK
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+try:
+    import pandas as pd
+except ImportError:
+    print("Please install the pandas package with 'pip install pandas' and try again.")
+    exit(1)
+
+import argparse
+
+_VERSION = "1.01"
+
+class ExplicitDefaultsHelpFormatter(argparse.ArgumentDefaultsHelpFormatter):
+    def _get_help_string(self, action):
+        if action.default is None or action.default is False:
+            return action.help
+        return super()._get_help_string(action)
+
+def main(args):
+    """
+    This script flags (by setting True the corresponding entry of
+    the hall_long_word column) those sentences where at least one
+    word is abnormally long; the abnormality is set through the 
+    thresh parameter, whose default value is 40.
+    """
+
+    if (parsed_args.version): 
+        print(f"Version {_VERSION} of anomalous string detector")
+        exit(1)
+
+    if not (tsv_files_specified):
+        print("--tsv-InFile and --tsv-OutFile are both required")
+        parser.print_usage()
+        exit(1)
+
+    inDF = pd.read_csv(args.tsv_InFile, sep='\t', dtype=str, low_memory=False, na_filter=False, quoting=3)
+    try:
+        txt = inDF[parsed_args.column]
+    except KeyError:
+        print("Error in reading column <"+parsed_args.column+"> in TSV file")
+        exit(1)
+
+    flag = []
+    for line in txt:
+        anomal = False
+        try:
+            words = line.split()
+        except TabError:
+            words = []
+        for w in words:
+            lw=len(w.strip())
+            if lw > parsed_args.thresh:
+                if args.quiet:
+                    flag.append("True")
+                else:
+                    flag.append("True ("+str(lw)+"): "+w.strip())
+                anomal = True
+                break
+        if not anomal:
+            flag.append("False")
+
+    inDF['hall_long_word'] = flag
+    inDF.to_csv(args.tsv_OutFile, sep="\t", index=False, quoting=3)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(formatter_class=ExplicitDefaultsHelpFormatter)
+
+    # I/O related arguments
+    parser.add_argument(
+        '--tsv-InFile', '-i', type=str,
+        help="The input TSV file [Mandatory]")
+
+    parser.add_argument(
+        '--tsv-OutFile', '-o', type=str,
+        help="The output TSV file [Mandatory. If equal to input TSV file, the new column is added to the original file]")
+
+    # Processing arguments:
+    parser.add_argument(
+        '--column', '-c', default='source',
+        help="Column name of the text to process [Optional]")
+
+    parser.add_argument(
+        '--thresh', '-t', type=int, default=40,
+        help="Max number of chars of a string to be unflagged [Optional]")
+
+    # Reporting related arguments
+    parser.add_argument(
+        '--quiet', '-q', default=False, action='store_true',
+        help='Print only True/False, no explanation for True\'s')
+
+    # Get version information:
+    parser.add_argument(
+        '--version', '-v', action='store_true', default=False,
+        help="Print version of the script and exit")
+
+    
+    parsed_args = parser.parse_args()
+    tsv_files_specified = \
+        getattr(parsed_args, 'tsv_InFile') is not None \
+        and len(parsed_args.tsv_InFile) > 0 \
+        and getattr(parsed_args, 'tsv_OutFile') is not None \
+        and len(parsed_args.tsv_OutFile) > 0
+
+    main(parsed_args)

scripts/flagHallucinations.py

@@ -0,0 +1,169 @@
+# Copyright 2024 FBK
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+try:
+    import pandas as pd
+except ImportError:
+    print("Please install the pandas package with 'pip install pandas' and try again.")
+    exit(1)
+
+import argparse
+
+_VERSION = "1.01"
+
+class ExplicitDefaultsHelpFormatter(argparse.ArgumentDefaultsHelpFormatter):
+    def _get_help_string(self, action):
+        if action.default is None or action.default is False:
+            return action.help
+        return super()._get_help_string(action)
+
+# max size of pattern (seq of words) that,
+# if repeated at least thresh1grams/threshNgrams times,
+# risesflags the hallucination:
+maxN = 5
+
+def findHall(wrd):
+    for N in range(maxN, 0, -1):
+        count = 0
+        for idx in range(0,len(wrd)-2*N+2): # the max idx value must be leave
+                                            # room for at least one repetition
+                                            # of the N_sized pattern 
+            count += hallLen(idx,N,wrd)
+            if ( N<3  and count+1>=parsed_args.thresh1grams ) or \
+               ( N>=3 and count+1>=parsed_args.threshNgrams ):
+                return [N, idx, count] 
+            else:
+                count = 0 # reset
+                
+    return [0,0,0]
+
+def hallLen(startIdx,N,wrd):
+    hallLen = 0
+    startRep = startIdx + N # first index after the end of the current pattern
+    while startRep < len(wrd)-N+1:
+        if isHall(startIdx,startRep,N,wrd):
+            hallLen+=1
+            startRep+=N
+        else:
+            break
+    return hallLen
+
+def isHall(s1,s2,N,wrd):
+    i = 0
+    while i<N and wrd[s1+i] == wrd[s2+i]:
+        i+=1
+    return i == N
+    
+def main(args):
+    """
+    This script flags (by setting True the corresponding entry 
+    of the hall_repeated_ngrams column) those sentences where a 
+    pattern (n-gram, that is a sequence of n words) is repeated 
+    at least a given number of times; for patterns of size 1 to 2, 
+    the minimum number of times for flagging it is set by the 
+    thresh1grams parameter (default value: 4), for those of size 
+    3-5 by threshNgrams (2)
+    """
+
+    if (parsed_args.version): 
+        print(f"Version {_VERSION} of anomalous string detector")
+        exit(1)
+
+    if not (tsv_files_specified):
+        print("--tsv-InFile and --tsv-OutFile are both required")
+        parser.print_usage()
+        exit(1)
+
+    if not (wrong_thresh_values):
+        print("--thresh1grams and --threshNgrams must both be positive integers")
+        parser.print_usage()
+        exit(1)
+
+    try:
+        inDF = pd.read_csv(args.tsv_InFile, sep='\t', dtype=str, low_memory=False, na_filter=False, quoting=3)
+    except IOError:
+        print("Error in opening "+args.tsv_InFile+" file")
+
+    try:
+        txt = inDF[parsed_args.column]
+    except KeyError:
+        print("Error in reading column <"+parsed_args.column+"> in TSV file")
+        exit(1)
+
+    flag = []
+    for line in txt:
+        words = line.split()
+        [size, idx, count] = findHall(words)
+        if size>0:
+            if args.quiet:
+                flag.append("True")
+            else:
+                flag.append("True (pattern of length " + str(size) + \
+                            " from index " + str(idx) + \
+                            ", repeated at least " + str(count+1) + " times)")
+        else:
+            flag.append("False")
+
+    inDF['hall_repeated_ngrams'] = flag
+    inDF.to_csv(args.tsv_OutFile, sep="\t", index=False, quoting=3)
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(formatter_class=ExplicitDefaultsHelpFormatter)
+
+    # I/O related arguments
+    parser.add_argument(
+        '--tsv-InFile', '-i', type=str,
+        help="The input TSV file [Mandatory]")
+
+    parser.add_argument(
+        '--tsv-OutFile', '-o', type=str,
+        help="The output TSV file [Mandatory. If equal to input TSV file, the new column is added to the original file]")
+
+    # Processing arguments:
+    parser.add_argument(
+        '--column', '-c', default='source',
+        help="Column name of the text to process [Optional]")
+    
+    parser.add_argument(
+        '--thresh1grams', '-u', type=int, default=4,
+        help="Threshold for 1-2_word hallucinations [Optional]")
+
+    parser.add_argument(
+        '--threshNgrams', '-n', type=int, default=2,
+        help="Threshold for 3-5_word hallucinations [Optional]")
+
+    # Reporting related arguments
+    parser.add_argument(
+        '--quiet', '-q', default=False, action='store_true',
+        help='Print only True/False, no explanation for True\'s')
+
+    # Get version information:
+    parser.add_argument(
+        '--version', '-v', action='store_true', default=False,
+        help="Print version of the script and exit")
+
+    
+    parsed_args = parser.parse_args()
+    tsv_files_specified = \
+        getattr(parsed_args, 'tsv_InFile') is not None \
+        and len(parsed_args.tsv_InFile) > 0 \
+        and getattr(parsed_args, 'tsv_OutFile') is not None \
+        and len(parsed_args.tsv_OutFile) > 0
+
+    wrong_thresh_values = parsed_args.thresh1grams > 0 \
+                          and parsed_args.threshNgrams > 0
+    
+    
+    main(parsed_args)

scripts/flagSuspiciousSingleWord.py

@@ -0,0 +1,192 @@
+# Copyright 2024 FBK
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License
+
+try:
+    import pandas as pd
+except ImportError:
+    print("Please install the pandas package with 'pip install pandas' and try again.")
+    exit(1)
+
+import argparse
+
+_VERSION = "1.01"
+
+class ExplicitDefaultsHelpFormatter(argparse.ArgumentDefaultsHelpFormatter):
+    def _get_help_string(self, action):
+        if action.default is None or action.default is False:
+            return action.help
+        return super()._get_help_string(action)
+
+def processColumn(col, dict):
+    # compute the counts of words that appear alone in the lines
+    for line in col:
+        if len(line.split()) == 1:
+            key=line.strip()
+            if key in dict:
+                dict[key]+=1
+            else:
+                dict[key]=1
+
+def processTSVfiles(files, dict):
+    # open and process textual content of each TSV file in the input list;
+    # return the word with the greatest count
+    for tsv in files:
+        try:
+            inDF = pd.read_csv(tsv, sep='\t', dtype=str, low_memory=False, na_filter=False, quoting=3)
+        except IOError:
+            print("Error in opening "+tsv+" file")
+        try:
+            col = inDF[parsed_args.column]
+        except KeyError:
+            print("Error in reading column <"+parsed_args.column+"> in TSV file")
+            exit(1)
+        processColumn(col, dict)
+    return findSuspiciousWord(dict)
+        
+def findSuspiciousWord(dict):
+    # look for the word in dict with the greatest count
+    argmax = ""
+    max = -1
+    for w,c in list(dict.items()):
+        if c > max:
+            max = c
+            argmax = w
+    return argmax
+
+    
+                
+def main(args):
+    """
+    This script flags (by setting True the corresponding entry of 
+    the hall_frequent_single_word) those sentences which consists 
+    of only one single suspicious word. This word can be either passed 
+    as a parameter (suspiciousWord option) or found inside the TSV 
+    input files. In the latter case, it is set as the most frequent 
+    word in the text included in files to be inspected. 
+    The TSV files to inspect can be passed through the 
+    tsv-SuspiciousWordFiles option. If no explicit suspiciousWord nor 
+    tsv-SuspiciousWordFiles is passed, the tsv-InFile is inspected. 
+    """
+
+    # Support structure:
+    dict = {}
+    
+    if (parsed_args.version): 
+        print(f"Version {_VERSION} of anomalous string detector")
+        exit(1)
+
+    if not (tsv_files_specified):
+        print("--tsv-InFile and --tsv-OutFile are both required")
+        parser.print_usage()
+        exit(1)
+
+    if (contrastive_options):
+        print("Either specify SuspiciousWord or SuspiciousWordFiles, both cannot be passed")
+        parser.print_usage()
+        exit(1)
+
+    """
+    Get the suspiciousWord:
+    """
+    if getattr(parsed_args, 'suspiciousWord') is not None:
+        # passed as parameter
+        suspiciousWord = parsed_args.suspiciousWord.strip()
+    elif getattr(parsed_args, 'tsv_SuspiciousWordFiles') is not None:
+        # to be searched in TSV files passed for that
+        suspiciousWord = processTSVfiles(parsed_args.tsv_SuspiciousWordFiles, dict)
+    else:
+        # to be searched in the input TSV file to process
+        suspiciousWord = processTSVfiles([parsed_args.tsv_InFile], dict)
+
+
+    # open input TSV file and get the text to process
+    try:
+        inDF = pd.read_csv(args.tsv_InFile, sep='\t', dtype=str, low_memory=False, na_filter=False, quoting=3)
+
+    except IOError:
+        print("Error in opening "+tsv+" file")
+    
+    try:
+        txt = inDF[parsed_args.column]
+    except KeyError:
+        print("Error in reading column <"+parsed_args.column+"> in TSV file")
+        exit(1)
+
+    # scan each input line and check if it consists of
+    # only the suspicious word
+    flag = []
+    for line in txt:
+        if suspiciousWord == line.strip():
+            if args.quiet:
+                flag.append("True")
+            else:
+                flag.append("True ("+suspiciousWord+")")
+        else:
+            flag.append("False")
+
+    # add the column to the original Data Frame read from the input TSV file
+    # and store the updated Data Frame in the output TSV file:
+    inDF['hall_frequent_single_word'] = flag
+    inDF.to_csv(args.tsv_OutFile, sep="\t", index=False, quoting=3)
+
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser(formatter_class=ExplicitDefaultsHelpFormatter)
+
+    # I/O related arguments
+    parser.add_argument(
+        '--tsv-InFile', '-i', type=str,
+        help="The input TSV file [Mandatory]")
+
+    parser.add_argument(
+        '--tsv-OutFile', '-o', type=str,
+        help="The output TSV file [Mandatory. If equal to input TSV file, the new column ('suspicious single word') is added to the original file]")
+
+    parser.add_argument(
+        '--tsv-SuspiciousWordFiles', '-s', type=str, nargs='+',
+        help="The TSV file(s) used to look for the suspicious word [Optional. If not present, the input TSV file is used instead]")
+
+    # Processing arguments:
+    parser.add_argument(
+        '--column', '-c', default='source',
+        help="Column name of the text to process [Optional]")
+
+    parser.add_argument(
+        '--suspiciousWord', '-w', type=str, 
+        help="suspicious word [if not specified, found in other TSV files passed as parameters]")
+
+    # Reporting related arguments
+    parser.add_argument(
+        '--quiet', '-q', default=False, action='store_true',
+        help='Print only True/False, no explanation for True\'s')
+
+    # Get version information:
+    parser.add_argument(
+        '--version', '-v', action='store_true', default=False,
+        help="Print version of the script and exit")
+
+    
+    parsed_args = parser.parse_args()
+    tsv_files_specified = \
+        getattr(parsed_args, 'tsv_InFile') is not None \
+        and len(parsed_args.tsv_InFile) > 0 \
+        and getattr(parsed_args, 'tsv_OutFile') is not None \
+        and len(parsed_args.tsv_OutFile) > 0
+
+    contrastive_options = \
+        getattr(parsed_args, 'tsv_SuspiciousWordFiles') is not None \
+        and getattr(parsed_args, 'suspiciousWord') is not None
+
+    main(parsed_args)