Saving transcriptions for split train step 500.

.gitattributes

@@ -56,3 +56,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,46 @@
+
+---
+YAML tags: 
+annotations_creators:
+  - no-annotation
+language_creators:
+  - found
+license:
+- other
+multilinguality:
+  - multilingual
+pretty_name:  ncc_speech_v7
+size_categories:
+  - 2G<n<1B
+source_datasets:
+  - original
+task_categories:
+  - automatic-speech-recognition
+task_ids:
+  - language-modeling
+configs:
+  - config_name: None
+    description: "This dataset does not need any config file."
+---
+
+## Dataset Card: NbAiLab/distil_raw_ncc_speech_v7
+  - Internal dataset created as input for creating Pseudo Labels.
+
+## General Information
+The dataset is based on ncc_speech_v7 (Norwegian Colossal Corpus - Speech). It is then filtered by only including entries where the text language in Norwegian, and where the source is not from "nrk_translate".
+
+ 
+## Potential Use Cases
+The ncc_speech_v7 corpus can be used for various purposes, including but not limited to:
+
+- Training Automatic Speech Recognition models.
+- Building text-to-speech systems.
+- Research in speech recognition and natural language processing.
+- Developing language models.
+
+## License
+The ncc_speech_v7 corpus has a private license.
+
+## Citation
+The corpus was created and cleaned by Freddy Wetjen, Rolv-Arild Braaten, Angelina Zanardi and Per Egil Kummervold. No publication is so far published based on this copus. 
+

distil_raw_ncc_speech_v7.py

@@ -0,0 +1,190 @@
+import argparse
+from google.cloud import storage
+import io
+import json
+import tarfile
+import datasets
+
+_CITATION = """\
+# Citation details
+"""
+
+_DESCRIPTION = """\
+This database was created from NB deposit recordings
+"""
+
+_HOMEPAGE = "https://ai.nb.no"
+
+_GCS_BUCKET = "nb-datasets"
+_GCS_BASE_PATH = "distil_raw_ncc_speech_v7/data/{split}/ncc_speech_v7-{lang_code}-{shard_idx:04d}-{shard_total:04d}"
+
+_SHARDS = {
+    "no": {
+        datasets.Split.TRAIN: 256,
+        datasets.Split.VALIDATION: 1,
+        datasets.Split.TEST: 1,
+    },
+}
+
+_SOURCES = ["audio_books_no","clean_audio_books_no","clean_stortinget_no","norwegian_fleurs","nrk_no","nst","stortinget_no"]
+_SHARDS["no"].update({f"validation_{source}": 1 for source in _SOURCES })
+_SHARDS["no"].update({f"test_{source}": 1 for source in _SOURCES})
+
+class distil_raw_ncc_speech_v7Config(datasets.BuilderConfig):
+    def __init__(self, *args, **kwargs):
+        super(distil_raw_ncc_speech_v7Config, self).__init__(*args, **kwargs)
+
+class distil_raw_ncc_speech_v7(datasets.GeneratorBasedBuilder):
+    DEFAULT_WRITER_BATCH_SIZE = 1000
+    BUILDER_CONFIGS = [
+        distil_raw_ncc_speech_v7Config(
+            name="no",
+            version=datasets.Version("1.0.1"),
+            description="ncc_speech Norwegian",
+        ),
+    ]
+
+    def __init__(self, *args, post_processors=None, **kwargs):
+        if not isinstance(post_processors, (tuple, list)):
+            post_processors = [post_processors]
+        self.post_processors = post_processors
+        super().__init__(*args, **kwargs)
+
+    def _info(self):
+        sampling_rate = 16000
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features({
+                "id": datasets.Value("string"),
+                # ... (your existing features)
+            }),
+            supervised_keys=None,
+            homepage=_HOMEPAGE,
+            citation=_CITATION,
+        )
+
+    def _info(self):
+        sampling_rate = 16000
+        return datasets.DatasetInfo(
+            description=_DESCRIPTION,
+            features=datasets.Features({
+                "id": datasets.Value("string"),
+                "group_id": datasets.Value("string"),
+                "source": datasets.Value("string"),
+                "audio_language": datasets.Value("string"),
+                "audio": datasets.features.Audio(sampling_rate=sampling_rate),
+                "audio_duration": datasets.Value("int32"),
+                "previous_text": datasets.Value("string"),
+                "text_en":datasets.Value("string"),
+                "text_language": datasets.Value("string"),
+                "text": datasets.Value("string"),
+                "timestamped_text_en": datasets.Value("string"),
+                "text_en": datasets.Value("string"),
+                "timestamped_text": datasets.Value("string"),
+                "wav2vec_wer": datasets.Value("float32"),
+                "whisper_wer": datasets.Value("float32"),
+                "verbosity_level": datasets.Value("int32"),
+                "file": datasets.Value("string"),
+                "channels": datasets.Value("int32"),
+                "frequency": datasets.Value("int32"),
+                "language": datasets.Value("string"),
+                "task": datasets.Value("string"),
+                "_post_processor": datasets.Value("string"),
+            }),
+            supervised_keys=None,
+            homepage=_HOMEPAGE,
+            citation=_CITATION,
+            # task_templates=[
+            #     AutomaticSpeechRecognition(
+            #         audio_column="audio",
+            #         transcription_column="text"
+            #     )
+            # ],
+        )
+
+    def _split_generators(self, dl_manager):
+        data_urls = {}
+        splits = _SHARDS[self.config.name].keys()
+        for split in splits:
+            data_urls[split] = []
+            shard_total = _SHARDS["no"][split]
+            for shard_idx in range(1, shard_total + 1):
+                string_formatting = dict(
+                    split=split,
+                    lang_code="no",
+                    shard_idx=shard_idx,
+                    shard_total=shard_total
+                )
+                gcs_path = _GCS_BASE_PATH.format(**string_formatting)
+                metadata_path = f"{gcs_path}.json"
+                archive_path = f"{gcs_path}.tar.gz"
+                data_urls[split].append((metadata_path, archive_path))
+
+        return [
+            datasets.SplitGenerator(
+                name=split, gen_kwargs={
+                    "filepaths": data_urls[split],
+                }
+            ) for split in splits
+        ]
+
+    def _generate_examples(self, filepaths):
+        storage_client = storage.Client()
+        data_fields = list(self._info().features.keys())
+        data_fields.remove("audio")
+
+        for metadata_path, archive_path in filepaths:
+            metadata_bucket = storage_client.bucket(_GCS_BUCKET)
+            metadata_blob = metadata_bucket.blob(metadata_path)
+            json_data = metadata_blob.download_as_text()
+            metadata_records = json_data.split('\n')
+            metadata_content =  {}
+            for record in metadata_records:
+                if record.strip():
+                    #print(record)
+                    metadata_object=json.loads(record)
+                    metadata_key = metadata_object["id"]
+                    metadata_content[metadata_key]= metadata_object
+
+                    #metadata_content = json.loads(metadata_blob.download_as_text().split("\n"))
+
+            archive_bucket = storage_client.bucket(_GCS_BUCKET)
+            archive_blob = archive_bucket.blob(archive_path)
+            archive_bytes = io.BytesIO(archive_blob.download_as_bytes())
+
+            # with tarfile.open(fileobj=archive_bytes, mode="r") as tar:
+            #     for audio_file in tar.getmembers():
+            #         if audio_file.isfile() and audio_file.name.endswith(".mp3"):
+            #             audio_bytes = tar.extractfile(audio_file).read()
+            #             audio_dict = {"bytes": audio_bytes, "path": audio_file.name}
+            #             yield metadata_content['id'], {"audio": audio_dict, **metadata_content}
+
+
+            with tarfile.open(fileobj=archive_bytes, mode="r") as tar:
+                for audio_file in tar.getmembers():
+                    if audio_file.isfile() and audio_file.name.endswith(".mp3"):
+                        metadata_key = f'{audio_file.name.replace(".mp3", "")}'
+                        fields = {key: metadata_content[metadata_key].get(key, "") for key in data_fields}
+                        fields["file"] = fields["id"] + ".mp3"
+                        fields["channels"] = 1
+                        fields["frequency"] = 16000
+                        fields["task"] = "transcribe"
+                        fields["language"] = fields["text_language"]
+                        fields["_post_processor"] = None
+                        audio_bytes = tar.extractfile(audio_file).read()
+                        audio_dict = {"bytes": audio_bytes, "path": audio_file.name}
+                        metadata_dict = {
+                            "id": metadata_key,
+                            "audio": audio_dict,
+                            **fields
+                        }
+                        for func in self.post_processors:
+                            if func is None:
+                                yield metadata_key, metadata_dict
+                            else:
+                                func_name = func.__name__ if func.__name__ else hex(id(func)).replace("0x",
+                                                                                                      "lambda-")
+                                result = func(metadata_dict)
+                                if result:
+                                    result["_post_processor"] = func_name
+                                    yield f"{metadata_key}_{func_name}", result

train-transcription.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:62f8e34bc23ba8cb8efd1bf2da31b7a8f8cc32724dc06dfd5dc23fbb0d8920d4
+size 12622913