kaldi | official location of the Kaldi project | Speech library

$(echo $d | sed 's/.*\///g')#

cat /kaldi/README | sed "s/akiplaner/${n}/g" >  extracted/$nf/etc/README #

for d in /dir1/dataset/audios/*; do
    echo $d
    n=$(echo $d | sed 's/.*\///g') #
    nf=${n}
    echo $n $a $nf
    mkdir -p extracted/$nf/wav
    mkdir -p extracted/$nf/etc
    rm -f extracted/$nf/etc/prompts-original
    rm -f extracted/$nf/etc/PROMPTS
    cat /kaldi/README | sed "s/akiplaner/${n}/g" >extracted/$nf/etc/README #

    for f in $d/*.wav; do
        n2=$(echo $f | sed 's/.*\///g')
        n3=$(echo $n2 | sed 's/\.wav//g') # removing .wav from $n2 string
        echo $n2
        echo $n3
        cp $f extracted/$nf/wav/$n2
        #sox --vol 0.01 $f -t wav extracted/$nf/wav/$n2;
        normalize-audio -a 0.3 extracted/$nf/wav/$n2

        cp $d/$n3.txt temp.txt

        echo "$n3 $(cat temp.txt)" >>extracted/$nf/etc/prompts-original
        echo "${nf}/mfc/${n3} $(cat temp.txt)" >>extracted/$nf/etc/PROMPTS
    done
    a=$(($a + 1))
done

Building DAG of jobs...
InputFunctionException in line 40 of Snakefile:
Error:
  WorkflowError:
    Missing wildcard values for MV_ID
Wildcards:

Traceback:
  File "Snakefile", line 35, in get_MV_IDs

import os


rule all:
  input:
    "mv_data/results.txt"


rule download_mv:
  params:
    allas="allas:2004354-mv/mv/",
    textgrid="mv_data/TEXTGRID",
    wav="mv_data/wav",
  output:
    textgrid="mv_data/TEXTGRID/{MV_ID}.TEX",
    wav="mv_data/wav/{MV_ID}.wav",
  shell:'''
    rclone copy {params.allas}/mv_original/TEXTGRID/ {params.textgrid}
    rclone copy {params.allas}/mv_added/wav/ {params.wav}
    '''


checkpoint textgrid_to_ctm_txt:
  input:
    textgrid="mv_data/TEXTGRID/{MV_ID}.TEX",
    script="data_preparation/read_mv_TextGrid.py"
  output:
    ctm="mv_data/ctm/{MV_ID}.ctm",
    txt="mv_data/txt/{MV_ID}.txt",
  shell:
    "python {input.script} {input.textgrid}"


def get_MV_IDs(wildcards):
  checkpoint_output = checkpoints.textgrid_to_ctm_txt.get(**wildcards).output[0]
  TMP_VAR, = glob_wildcards(os.path.join(checkpoint_output,"{MV_ID}.TEX"))
  return expand(os.path.join(checkpoint_output,"{mv_id}.TEX"),mv_id=TMP_VAR)


rule merge_ctms:
  input:
    get_MV_IDs
  output:
    gold_ctm="mv_data/ctm/ctm",
  shell:
    "cat {input.get_MV_IDs} > {output.gold_ctm}"


rule kaldi_align:
  input:
    gold_ctm="mv_data/ctm/ctm",
    script="interfaces/kaldi-align.py",
  params:
    alignments="mv_data/align",
    wav="mv_data/wav",
  output:
    created_ctm="mv_data/align/ctm",
  shell:'''
    python {input.script} --wav {params.wav} --txt mv_data/txt --lang fi {params.alignments} < kaldi-align_prompts
    '''


rule analyse_align:
  input:
    script="analysis/calculate_metrics.py",
    gold_ctm="mv_data/ctm/ctm",
    created_ctm="mv_data/align/ctm",
  output:
    results="mv_data/results.txt"
  shell:
    "python -m analysis.calculate_metrics {input.gold_ctm} {input.created_ctm} mv > {output.results}"


rule upload_print_results:
  input:
    results="mv_data/results.txt",
  params:
    allas="allas:2004354-mv/mv/",
  shell:
    "rclone copyto {input.results} {params.allas}"

import os


rule all:
  input:
    "mv_data/results.txt"


rule download_mv:
  params:
    allas="allas:2004354-mv/mv",
  output:
    textgrid=directory("mv_data/TEXTGRID"),
    wav=directory("mv_data/wav"),
  shell:'''
    rclone copy {params.allas}/mv_original/TEXTGRID/ {output.textgrid}
    rclone copy {params.allas}/mv_added/wav/ {output.wav}
    '''


checkpoint textgrid_to_ctm_txt:
  input:
    textgrid="mv_data/TEXTGRID",
    script="data_preparation/read_mv_TextGrid.py"
  output:
    ctm=directory("mv_data/ctm"),
    txt=directory("mv_data/txt"),
  shell:'''
    for textgrid in {input.textgrid}/*.TEX;
    do
      python {input.script} "$textgrid";
    done
    '''

rule merge_ctms:
  input:
    ctm="mv_data/ctm"
  output:
    gold_ctm="mv_data/gold_ctm",
  shell:
    "cat {input.ctm}/*.ctm > {output.gold_ctm}"


rule kaldi_align:
  input:
    wav="mv_data/wav",
    txt="mv_data/txt",
    script="interfaces/kaldi_align.py",
  params:
    alignments="mv_data/align",
  output:
    created_ctm="mv_data/align/ctm",
  shell:'''
    python {input.script} --wav {input.wav} --txt mv_data/txt --lang fi {params.alignments} < kaldi-align_prompts
    '''

rule analyse_align:
  input:
    script="analysis/calculate_metrics.py",
    gold_ctm="mv_data/gold_ctm",
    created_ctm="mv_data/align/ctm",
  output:
    results="mv_data/results.txt"
  shell:
    "python -m analysis.calculate_metrics {input.gold_ctm} {input.created_ctm} mv > {output.results}"


rule upload_print_results:
  input:
    results="mv_data/results.txt",
  params:
    allas="allas:2004354-mv/mv/",
  shell:
    "rclone copyto {input.results} {params.allas}"

from flask import Flask

import sys
import os
import json

import pika
import uuid
import time

''' HEADERS = {'Content-type': 'audio/*', 'Accept': 'text/plain'}'''

class RPIclient(object):
        def __init__(self):
            self.connection = pika.BlockingConnection(
                pika.ConnectionParameters(host='rabbitmq'))
            self.channel = self.connection.channel()
            self.channel.basic_qos(prefetch_count=1)
            self.channel.exchange_declare(exchange='kaldi_expe', exchange_type='topic')

            # Create all the queue and bind them to the corresponding routing key
            self.channel.queue_declare('request', durable=True)
            result = self.channel.queue_declare('answer', durable=True)

            self.channel.queue_bind(exchange='kaldi_expe', queue='request', routing_key='kaldi_expe.web.request')
            self.channel.queue_bind(exchange='kaldi_expe', queue='answer', routing_key='kaldi_expe.kaldi.answer')
            self.callback_queue = result.method.queue

            self.channel.basic_consume(queue="answer", on_message_callback=self.on_response)

        def on_response(self, ch, method, props, body):
            print("from server, correlation id : " + str(props.correlation_id), file=sys.stderr)
            self.response = body
            ch.basic_ack(delivery_tag=method.delivery_tag)

        def call(self, n):
            print("Launched Call ")
            self.response = None
            self.corr_id = str(uuid.uuid4())
            self.channel.basic_publish(
                exchange='kaldi_expe',
                routing_key='kaldi_expe.web.request',
                properties=pika.BasicProperties(
                    correlation_id=self.corr_id,
                ),
                body=str(n))
            while self.response is None:
                self.connection.process_data_events()
            return int(2)

def flask_app():
    app = Flask("__name__")

    @app.route('/', methods=['GET'])
    def server_is_up():
        return 'server is up', 200

    @app.route('/add-job/<cmd>')
    def add(cmd):
        app.config['RPIclient'].call(10)
        return "Call RPI client",404

    return app

if __name__ == '__main__':
    print("Waiting for RabbitMq")
    time.sleep(20)
    rpiClient = RPIclient()
    app = flask_app()
    app.config['RPIclient'] = rpiClient
    print("Rabbit MQ is connected, starting server", file=sys.stderr)
    app.run(debug=True, threaded=False, host='0.0.0.0')

import pika
import time
import sys

print(' [*] Waiting for RabbitMQ ...')
time.sleep(20)

print(' [*] Connecting to server ...')
channel = connection.channel()

print(' [*] Waiting for messages.')
def callback(ch, method, properties, body):
    print(" [x] Received %s" % body)
    print(" [x] Executing task ")
    print("from worker, correlation id : " + str(properties.correlation_id))
    ch.basic_publish(
                exchange='kaldi_expe',
                routing_key='kaldi_expe.kaldi.answer',
                properties=pika.BasicProperties(correlation_id = properties.correlation_id),
                body="response")
    print(" [x] Done")

    ch.basic_ack(delivery_tag=method.delivery_tag)

channel.basic_qos(prefetch_count=1)
channel.basic_consume(queue='request', on_message_callback=callback)

channel.start_consuming()

import logging
import asyncio
import time
from concurrent.futures._base import CancelledError  

from .transcription import Transcriber, get_record_size_info

logging.basicConfig(level=logging.DEBUG)
record_file_name = '/var/spool/asterisk/monitor/callrecord.wav'    

def main():
    transcriber = Transcriber()       

    logging.getLogger('asyncio').setLevel(logging.ERROR)
    logging.getLogger('asyncio.coroutines').setLevel(logging.ERROR)
    logging.getLogger('websockets.server').setLevel(logging.ERROR)
    logging.getLogger('websockets.protocol').setLevel(logging.ERROR)

    loop = asyncio.get_event_loop()    
    time.sleep(2)

    prod_task = loop.create_task(transcriber.run_producer(transcriber._queue))
    consum_task = loop.create_task(transcriber.run_consumer(transcriber._queue))
            
    tasks = [prod_task, consum_task]
            
    executed, remaining = loop.run_until_complete(asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)) 
    logging.debug('Tasks completed: %s', executed)
    logging.debug('Tasks in progress: %s', remaining)

    for task in remaining:
        logging.info('Dropping task %s: %s', task, task.cancel())
    try:
        loop.run_until_complete(asyncio.gather(*remaining))
    except CancelledError:
        for running_task in remaining:
        logging.debug('Task dropped %s: %s', running_task, running_task.cancelled())                                         
            
    loop.stop()    
    loop.close()         

if __name__ == '__main__':
    main()       

from queue import Queue
from concurrent.futures._base import CancelledError 
from pathlib import Path

import logging
import asyncio
import websockets
import json

ASR_WS_ADDRESS = 'ws://127.0.0.1:2700'

class Transcriber:

    def __init__(self):
        self._queue = asyncio.Queue()
        self._buffer = b''
        self._current_record_size = 0 # terminate reading from wav file if current size of record is equal to total payload 
        self._record_file_name = '/var/spool/asterisk/monitor/callrecord.wav'
        self._total_payload = 0 # total of bytes written to buffer since call recording started  
           
    async def run_producer(self, qu):
        with open(self._record_file_name, 'rb') as record:
            print('call record file size: ' + str(get_record_size_info(self._record_file_name)))
            self._current_record_size = get_record_size_info(self._record_file_name)
            while True:
                await asyncio.sleep(0.5)
                chunk = record.read(16000)           
                qu.put_nowait(chunk)            
                qsize = qu.qsize()

    async def run_consumer(self, qu):
        while True:            
            data = await qu.get()             
            await asyncio.sleep(1)
            self._buffer += data                      
            self._current_record_size = get_record_size_info(self._record_file_name)            
            print('now buffer contains : ' + str(len(self._buffer)) + ' bytes')
            print('current record size: ' + str(self._current_record_size) + ' bytes')
            print('current total payload: ' + str(self._total_payload) + ' bytes')           
           
            if len(self._buffer) >= 288000:                
                await self.do_recognition()
                self._total_payload += len(data)
                self._buffer = b''               
            elif len(data) == 0 and self._current_record_size == self._total_payload:
                print('looks like recording is complete...')
                await self.do_recognition()               
                self._queue._queue.clear() # remove items from queue before loop gets close      
                self._queue._finished.set()
                self._queue._unfinished_tasks = 0               
                raise Exception('cancel both tasks and close loop')
            else:
                self._total_payload += len(data)
                continue
    
    async def do_recognition(self):
        async with websockets.connect(ASR_WS_ADDRESS) as ws:        
            logging.debug('Sending %s to Vosk-hosted Kaldi engine', len(self._buffer))
            await ws.send(self._buffer)
                                     
            response = json.loads(await ws.recv())
            try:
                result = response['partial']
                if len(result) > 0:
                print('\n')
                print(result + '\n')
            except KeyError:
                result = response['text']
                if len(result) > 0:
                print('\n')
                print(result + '\n')    

def get_record_size_info(record_file_name):
    return Path(record_file_name).stat().st_size

  awk '{if ($2 == "#csid") print $1" "($4+$5+$6)}' $dir/analysis/per_utt_details.txt > $dir/edits.txt

     ref
     hyp
     op
     #csid 0 0 0 0
     ...repeat the above 4 lines.

#include <iostream>
#include <iomanip>
#include <fstream>
#include <vector>
#include <map>
#include <algorithm>
#include <random>
#include <unistd.h>
#include <cmath>
#include <stdlib.h>
#include <mutex>
#include <sys/wait.h>
#include <filesystem>
#include <string>
#include <pthread.h>

#define time_str(s) (s < 60 ? (to_string(s) + " second(s)") : (s < 3600 ? (to_string((s) / 60) + " minute(s)") : (to_string((s) / 3600) + " hour(s) and " + to_string(((s) % 3600) / 60) + " minute(s)")))
using namespace std;
namespace fs = std::filesystem;

struct MyGenom
{
    vector<string> filepaths;
    map<string, string> seq;
};

void check_rv(int rv) {
    if (rv != 0) {
        printf("Error: Value is %d\n", rv);
        exit(1);
    }
}

struct Reference_Genome {
    static long unsigned int idx;
    static map <string, string> seq;
    static pthread_mutex_t mtxLock;
    static vector <string> filepaths;

    static void writing(string path) {
        ifstream rsf(path);
        string line, cur_chr;
        while (getline(rsf, line)) {
            if (line.substr(0, 1) == ">") {
                cur_chr = line.substr(1);
                seq[cur_chr] = "";
            } else
                seq[cur_chr] += line;
        }
        rsf.close();
    }

    static void *distribution(void *var) {
        string path;
        while (idx < filepaths.size()) {
            check_rv(pthread_mutex_lock(&mtxLock));
            path = filepaths[idx];
            idx++;
            check_rv(pthread_mutex_unlock(&mtxLock));
            writing(path);
        }
        return NULL;
    }

    Reference_Genome(string dir, unsigned int n_threads) {
        cout << "Reading the reference genome from \'" << dir << "\'" << endl;
        for (const auto &entry : fs::directory_iterator(dir))
            filepaths.push_back(entry.path());
        time_t t1 = time(NULL);
        idx = 0;
        // init lock
        int rv = pthread_mutex_init(&mtxLock, NULL);
        check_rv(rv);
        pthread_t workers[n_threads];
        int rs;
        struct MyGenom param;
        for (unsigned int th = 0; th < n_threads; th++) {
            rs = pthread_create(&workers[th], NULL, distribution, (void *)((unsigned long)th));
            check_rv(rs);
        }
        for (unsigned int th = 0; th < n_threads; th++) {
            rs = pthread_join(workers[th], NULL);
            check_rv(rs);
        }
        pthread_mutex_destroy(&mtxLock);

        time_t t2 = time(NULL);
        cout << filepaths.size() << " sequences were read in " << time_str((long) t2 - (long) t1)
             << ".\n----------------\n";
    }
};

int main(int argc, char const *argv[]) {
    string dir = "./data/ex_seq";
    unsigned int n_threads = 5;
    Reference_Genome ref(dir, n_threads);
    cout << "chr6: " << ref.seq["chr6"] << endl;
    cout << "chr9: " << ref.seq["chr9"] << endl;
    cout << "chr13: " << ref.seq["chr13"] << endl;
}

testSeq.cpp:97: undefined reference to `Reference_Genome::seq[abi:cxx11]'
/usr/bin/ld: testSeq.cpp:98: undefined reference to `Reference_Genome::seq[abi:cxx11]'
/usr/bin/ld: testSeq.cpp:99: undefined reference to `Reference_Genome::seq[abi:cxx11]'
/usr/bin/ld: /tmp/cctfwVX2.o: in function `Reference_Genome::writing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >)':
/testSeq.cpp:46: undefined reference to `Reference_Genome::seq[abi:cxx11]'
/usr/bin/ld: testSeq.cpp:48: undefined reference to `Reference_Genome::seq[abi:cxx11]'
/usr/bin/ld: /tmp/cctfwVX2.o: in function `Reference_Genome::distribution(void*)':
testSeq.cpp:55: undefined reference to `Reference_Genome::filepaths[abi:cxx11]'
/usr/bin/ld: testSeq.cpp:55: undefined reference to `Reference_Genome::idx'
/usr/bin/ld: testSeq.cpp:56: undefined reference to `Reference_Genome::mtxLock'
/usr/bin/ld: testSeq.cpp:57: undefined reference to `Reference_Genome::idx'
/usr/bin/ld: testSeq.cpp:57: undefined reference to `Reference_Genome::filepaths[abi:cxx11]'
/usr/bin/ld: testSeq.cpp:58: undefined reference to `Reference_Genome::idx'
/usr/bin/ld: testSeq.cpp:58: undefined reference to `Reference_Genome::idx'
/usr/bin/ld: testSeq.cpp:59: undefined reference to `Reference_Genome::mtxLock'
/usr/bin/ld: /tmp/cctfwVX2.o: in function `Reference_Genome::Reference_Genome(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, unsigned int)':
testSeq.cpp:68: undefined reference to `Reference_Genome::filepaths[abi:cxx11]'
/usr/bin/ld: testSeq.cpp:70: undefined reference to `Reference_Genome::idx'
/usr/bin/ld: testSeq.cpp:72: undefined reference to `Reference_Genome::mtxLock'
/usr/bin/ld: testSeq.cpp:85: undefined reference to `Reference_Genome::mtxLock'
/usr/bin/ld: testSeq.cpp:88: undefined reference to `Reference_Genome::filepaths[abi:cxx11]'
collect2: error: ld returned 1 exit status

FORMAT = pyaudio.paInt16
CHANNELS = 1
RATE = 16000
CHUNK = 4800
RECORD_SECONDS = 5
WAVE_OUTPUT_FILENAME = "recordedFile.wav"
device_index = 1
audio = pyaudio.PyAudio()

HOST = 'ip'
PORT = 5000

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))

index = (input())
print("recording via index "+str(index))

stream = audio.open(format=FORMAT, channels=CHANNELS,
                rate=RATE, input=True,input_device_index = 1,
                frames_per_buffer=CHUNK)
print ("recording started")
Recordframes = []

for i in range(0, int(RATE / CHUNK * RECORD_SECONDS)):
    data = stream.read(CHUNK)
     s.sendall(data)
    Recordframes.append(data)
print ("recording stopped")

from exchangelib import Message
import io
import pydub
import speech_recognition as sr

r = sr.Recognizer()
def speech_to_text(Message):
    for attachment in Message.attachments:
        if attachment.content_type == 'audio/x-wav':
            content = attachment.content # Store attachment's binary data as a variable
            bytes = io.BytesIO(content) # Encode IO as bytes
            f= pydub.AudioSegment.from_file(bytes).export(attachment.name[:-4] +'.wav', format='wav') # Use bytes to create pydub's AudioSegment object
                                                                                                        # and export it as desired format
            with sr.AudioFile(f) as source: # Feed converted file into speech_recognition's AudioFile
                audio = r.record(source)
                transcript = r.recognize_google(audio)
                return transcript

import socket
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))