initial commit

csj.py

@@ -0,0 +1,390 @@
+# coding=utf-8
+# Copyright 2021 The TensorFlow Datasets Authors and the HuggingFace Datasets Authors.
+#
+# 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.
+
+# Lint as: python3
+"""CSJ: Corpus of Spontaneous Japanese for Automatic Speech Recognition."""
+
+
+import os
+import re
+from pathlib import Path
+
+import datasets
+import numpy as np
+import librosa
+from datasets.tasks import AutomaticSpeechRecognition
+import soundfile as sf
+
+_CITATION = """\
+@article{article,
+author = {Maekawa, Kikuo},
+year = {2003},
+month = {01},
+pages = {},
+title = {Corpus of Spontaneous Japanese: Its design and evaluation},
+journal = {Proceedings of SSPR}
+}
+"""
+
+_DESCRIPTION = """\
+Corpus of Spontaneous Japanese, or CSJ, is a large-scale database of spontaneous Japanese. It contains speech signal and transcription of about 7 million words along with various annotations like POS and phonetic labels. After describing its design issues, preliminary evaluation of the CSJ was presented. The results suggest strongly the usefulness of the CSJ as the resource for the study of spontaneous speech.
+"""
+
+_HOMEPAGE = "https://clrd.ninjal.ac.jp/csj/en/"
+
+_ROOT_DIRNAME = "csj"
+
+class CSJConfig(datasets.BuilderConfig):
+  """BuilderConfig for CSJ."""
+
+  def __init__(self, **kwargs):
+    """
+    Args:
+      data_dir: `string`, the path to the folder containing the files in the
+        downloaded .tar
+      citation: `string`, citation for the data set
+      url: `string`, url for information about the data set
+      **kwargs: keyword arguments forwarded to super.
+    """
+    # version history
+    # 0.1.0: First release
+    super(CSJConfig, self).__init__(version=datasets.Version("0.1.0", ""), **kwargs)
+      
+
+
+class CSJ(datasets.GeneratorBasedBuilder):
+  """CSJ dataset."""
+  DEFAULT_CONFIG_NAME = "all"
+  BUILDER_CONFIGS = [
+      CSJConfig(name="core", description="'core' speech."),
+      CSJConfig(name="noncore", description="'noncore', more challenging, speech."),
+      CSJConfig(name="all", description="Combined clean and other dataset."),
+  ]
+
+  @property
+  def manual_download_instructions(self):
+    return (
+      "To use CSJ you have to download it manually. "
+      "Please create an account and download the dataset from "
+      "https://clrd.ninjal.ac.jp/csj/en/ \n"
+      "Then load the dataset with: "
+      "`datasets.load_dataset('csj', data_dir='path/to/folder/folder_name')`"
+    )
+
+  def _info(self):
+    return datasets.DatasetInfo(
+      description=_DESCRIPTION,
+      features=datasets.Features(
+        {
+          "id": datasets.Value("string"),
+          "audio": datasets.Audio(sampling_rate=16_000),
+          "text": datasets.Value("string"),
+          "katakana": datasets.Value("string")
+        }
+      ),
+      supervised_keys=("file", "katakana"),
+      homepage=_HOMEPAGE,
+      citation=_CITATION,
+      task_templates=[AutomaticSpeechRecognition(audio_column="audio", transcription_column="katakana")],
+    )
+
+  def _split_generators(self, dl_manager):
+    # Step 1. Extract all zip files
+    # Step 2. Get scripts
+    # Step 3. Generate samples
+    data_dir = os.path.abspath(os.path.expanduser(dl_manager.manual_dir))
+    data_dir = os.path.join(data_dir, _ROOT_DIRNAME)
+    if not os.path.exists(data_dir):
+      raise FileNotFoundError(
+        f"{data_dir} does not exist. Make sure you insert a manual dir via"
+        "`datasets.load_dataset('csj', data_dir=...)`"
+        "that includes files. Manual download instructions:"
+        f"{self.manual_download_instructions}"
+      )
+    if self.config.name == 'default':
+      self.config.name = 'all'
+    
+    archive_paths = {}
+    for fname in os.listdir(data_dir):
+      if (fname.startswith(self.config.name) or (self.config.name == 'all')) and fname.endswith('.zip'):
+        fname_no_ext = os.path.splitext(fname)[0]
+        archive_paths[fname_no_ext] = os.path.join(data_dir, fname)
+    local_extracted_archives = dl_manager.extract(archive_paths)
+    
+    split_keys = {
+      "train": [],
+      "valid": [],
+      "test": []
+    }
+    if self.config.name == 'all':
+      split_keys["train"] = ["core.train", "noncore.train"]
+      split_keys["valid"] = ["core.valid", "noncore.valid"]
+      split_keys["test"] = ["core.test", "noncore.test"]
+    else:
+      for k in split_keys:
+        split_keys[k] = [f"{self.config.name}.{k}"] 
+
+    return [
+      datasets.SplitGenerator(
+        name=datasets.Split.TRAIN, 
+        gen_kwargs={
+          "target_keys": split_keys["train"],
+          "local_extracted_archives": local_extracted_archives
+        }
+      ),
+      datasets.SplitGenerator(
+        name=datasets.Split.VALIDATION, 
+        gen_kwargs={
+          "target_keys": split_keys["valid"], 
+          "local_extracted_archives": local_extracted_archives
+        }
+      ),
+      datasets.SplitGenerator(
+        name=datasets.Split.TEST, 
+        gen_kwargs={
+          "target_keys": split_keys["test"],
+          "local_extracted_archives": local_extracted_archives
+        }
+      )
+    ]
+
+  def _generate_examples(self, target_keys, local_extracted_archives):
+    """Generate examples from KsponSpeech archive_path based on the test/train trn information."""
+    # Iterating the contents of the data to extract the relevant information
+    """
+    audio_data = {
+      target_key: {
+        file_id: {
+          seg_id: String,
+          duration: Tuple(Float, Float),
+          channel: String
+        }
+      }
+    }
+    """
+    
+    metadata = {}
+    for k in target_keys:
+      local_extracted_archive = os.path.join(local_extracted_archives[k], k)
+      for fname in os.listdir(local_extracted_archive):
+        if fname.endswith('.trn'):
+          with open(os.path.join(local_extracted_archive, fname), encoding='cp932') as f:
+            words = []
+            seg_data = {}
+            is_stereo = False
+            file_id = os.path.splitext(fname)[0]
+            sentence = ''
+            katakana_sentence = ''
+            seg_id = ''
+            metadata[file_id] = {
+              'path': os.path.join(local_extracted_archive, fname),
+              'data': {}
+            }
+            for line in f:
+              if not line.startswith('%'):
+                if 'L:' in line or 'R:' in line:
+                  # audio line
+                  items = line.split(" ")
+                  if len(items) == 3:
+                    if seg_id != '' and sentence != '' and katakana_sentence != '':
+                      metadata[file_id]['data'][seg_id]['text'] = sentence.strip()
+                      metadata[file_id]['data'][seg_id]['katakana'] = parse_tag(katakana_sentence).strip()
+                      sentence = ''
+                      katakana_sentence = ''
+                    seg_id, duration, channel_slot = items
+                    start_sec, end_sec = duration.split("-")
+                    channel = channel_slot.split(":")[0]
+                    metadata[file_id]['data'][seg_id] = {
+                      'duration': (float(start_sec), float(end_sec)),
+                      'channel': channel
+                    }
+                    if channel == 'R':
+                      is_stereo = True
+                  else:
+                    print(f"None audio line contains ':' at {fname}\n->{line}")
+                elif '&' in line:
+                  # text line
+                  text, katakana = line.split('&')
+                  text = text.strip()
+                  katakana = katakana.strip()
+                  sentence += ' ' + text
+                  katakana_sentence += ' ' + katakana
+                else:
+                  print(f"Unknown line type. at {fname}\n->{line}")
+              elif '<EOT>' in line:
+                if seg_id != '' and sentence != '' and katakana_sentence != '':
+                  metadata[file_id]['data'][seg_id]['text'] = sentence.strip()
+                  metadata[file_id]['data'][seg_id]['katakana'] = parse_tag(katakana_sentence).strip()
+                  sentence = ''
+                  katakana_sentence = ''
+
+            if is_stereo:
+              file_id_left = file_id+'-L'
+              file_id_right = file_id+'-R'
+              metadata[file_id_left] = {
+                'path': metadata[file_id]['path'].replace(file_id, file_id_left),
+                'data': {}
+              }
+              metadata[file_id_right] = {
+                'path': metadata[file_id]['path'].replace(file_id, file_id_right),
+                'data': {}
+              }
+              for seg_id in metadata[file_id]['data']:
+                if metadata[file_id]['data'][seg_id]['channel'] == 'L':
+                  metadata[file_id_left]['data'][seg_id] = metadata[file_id]['data'][seg_id]
+                elif metadata[file_id]['data'][seg_id]['channel'] == 'R':
+                  metadata[file_id_right]['data'][seg_id] = metadata[file_id]['data'][seg_id]
+                else:
+                  print(f"Unknwon channel. at {file_id}, {seg_id}, {metadata[file_id]['data'][seg_id]['channel']}")
+              del metadata[file_id]
+
+    key = 0
+    for file_id in metadata:
+      audio_path = metadata[file_id]['path'].replace('.trn','.wav')
+      if os.path.exists(audio_path):  
+        audio_array, sampling_rate = sf.read(audio_path)
+        for seg_id in metadata[file_id]['data']:
+          if "katakana" in metadata[file_id]['data'][seg_id] and len(metadata[file_id]['data'][seg_id]['katakana']) > 0:
+            start_sec, end_sec = metadata[file_id]['data'][seg_id]["duration"]
+            start_idx = int(start_sec * sampling_rate)
+            end_idx = int(end_sec * sampling_rate)
+            audio_segment = audio_array[start_idx:end_idx]
+            audio = {
+              "path": f"{audio_path}:{start_sec}-{end_sec}",
+              "array": audio_segment,
+              "sampling_rate": sampling_rate
+            }
+            yield key, {
+              "id": file_id + '.' + seg_id,
+              "audio": audio,
+              "text": metadata[file_id]['data'][seg_id]["text"],
+              "katakana": metadata[file_id]['data'][seg_id]["katakana"]
+            }
+            key += 1
+      else:
+        print(f"Audio doesn't exist: {audio_path}")
+
+
+
+
+"""
+(F) 필러 
+  (F text) -> text
+(D) 다시 말하기
+  (D text) -> text
+(D2) 조사 등의 다시 말하기
+  (D2 text) -> text
+(?) 알아 듣기 어려워서 전사에 자신이 없는 경우
+  (? text) -> text
+  (? text1, text2) -> text1
+  (?) text -> text
+(M) 음이나 단어의 인용
+  (M text) -> text
+(R) 개인정보
+  (R xxx) -> ''
+(X) 비문법
+  (X text) -> text
+(A) 알파벳 또는 숫자, 기호의 표기 ; 앞은 발음 뒤는 표기
+  (A text; notation) -> text
+(K) 어떤 원인으로 한자표기가 할 수 없을 때
+  (K ひ(F いー) だり;左) -> ひいーだり
+(W) 일시적 발음 실수
+  (W mistake_pronounciation; correct_pronounciation) -> mistake_pronounciation
+(B) 배경지식 부족에 따른 말 실수
+  (B mistake_pronounciation; correct_pronounciation) -> mistake_pronounciation
+(笑) 웃으면서 말함
+  (笑 text) -> text
+(泣) 울면서 말함
+  (泣 text) -> text
+(咳) 기침하면서 말함
+  (咳 text) -> text
+(L) 속삭이거나 작은 목소리로 말함
+  (L text) -> text
+
+<FV> 보컬 플라이 등으로 모음을 식별 할 수없는 경우
+<VN> "응/흠/훙" 소리를 파악하기 어려운 경우
+<H> 쓸데없이 모음을 길게 발음
+<Q> 쓸데없이 자음을 길게 발음
+<笑> 웃음
+<泣> 움
+<咳> 기침
+<息> 숨소리
+<P> 2초 이상의 정적
+  <P:starttime-endtime> -> ''
+"""
+def deal_with_tag(tag, text):
+  result = text
+  if tag == '?':
+    if ',' in text:
+      result = text.split(',')[0].strip()
+    else:
+      result = text.strip()
+  elif tag == 'R':
+    result = ''
+  elif tag == 'A' or tag == 'B' or tag == 'W' or tag == 'K':
+    result = text.split(';')[0].strip()
+  return result
+
+def parse_tag(text):
+  tag_stack = []
+  content_stack = []
+  tag_flag = False
+  tag2_flag = False
+  content_flag = False
+  tag = ''
+  content = ''
+  result = ''
+  for c in text:
+    if tag2_flag:
+      if c == '>':
+        tag2_flag = False
+    else:
+      if tag_flag:
+        if c == ' ' or c == '?':
+          tag += c
+          tag_stack.append(tag.strip())
+          tag = ''
+          tag_flag = False
+          content_flag = True
+        else:
+          tag += c
+      elif c == '<':
+        tag2_flag = True
+      elif c == '(':
+        if content_flag:
+          content_stack.append(content)
+          content = ''
+        tag_flag = True
+      elif c == ')':
+        if content_flag:
+          processed_content = deal_with_tag(tag_stack.pop(), content)
+          if len(content_stack) == 0:
+            result += processed_content
+            content = ''
+            content_flag = False
+          else:
+            content = content_stack.pop()
+            content += processed_content
+        else:
+          content = ''
+      elif content_flag:
+        content += c
+      else:
+        result += c
+  assert '(' not in result, text
+  assert ')' not in result, text
+  assert '<' not in result, text
+  assert '>' not in result, text
+  return result