first commit

README.md

@@ -0,0 +1,5 @@
+[anton-l/wav2vec2-base-ft-keyword-spotting](https://huggingface.co/anton-l/wav2vec2-base-ft-keyword-spotting) model quantized with [Optimum OpenVINO](https://github.com/dkurt/optimum-openvino/).
+
+| Accuracy on eval (baseline) | Accuracy on eval (quantized) |
+|-----------------------------|----------------------------------------|
+| 0.9828 | 0.9553 (-0.0274) |

config.json

@@ -0,0 +1,117 @@
+{
+  "_name_or_path": "facebook/wav2vec2-base",
+  "activation_dropout": 0.0,
+  "apply_spec_augment": true,
+  "architectures": [
+    "Wav2Vec2ForSequenceClassification"
+  ],
+  "attention_dropout": 0.1,
+  "bos_token_id": 1,
+  "classifier_proj_size": 256,
+  "codevector_dim": 256,
+  "contrastive_logits_temperature": 0.1,
+  "conv_bias": false,
+  "conv_dim": [
+    512,
+    512,
+    512,
+    512,
+    512,
+    512,
+    512
+  ],
+  "conv_kernel": [
+    10,
+    3,
+    3,
+    3,
+    3,
+    2,
+    2
+  ],
+  "conv_stride": [
+    5,
+    2,
+    2,
+    2,
+    2,
+    2,
+    2
+  ],
+  "ctc_loss_reduction": "sum",
+  "ctc_zero_infinity": false,
+  "diversity_loss_weight": 0.1,
+  "do_stable_layer_norm": false,
+  "eos_token_id": 2,
+  "feat_extract_activation": "gelu",
+  "feat_extract_norm": "group",
+  "feat_proj_dropout": 0.1,
+  "feat_quantizer_dropout": 0.0,
+  "final_dropout": 0.0,
+  "finetuning_task": "audio-classification",
+  "freeze_feat_extract_train": true,
+  "hidden_act": "gelu",
+  "hidden_dropout": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "yes",
+    "1": "no",
+    "10": "_silence_",
+    "11": "_unknown_",
+    "2": "up",
+    "3": "down",
+    "4": "left",
+    "5": "right",
+    "6": "on",
+    "7": "off",
+    "8": "stop",
+    "9": "go"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "_silence_": "10",
+    "_unknown_": "11",
+    "down": "3",
+    "go": "9",
+    "left": "4",
+    "no": "1",
+    "off": "7",
+    "on": "6",
+    "right": "5",
+    "stop": "8",
+    "up": "2",
+    "yes": "0"
+  },
+  "layer_norm_eps": 1e-05,
+  "layerdrop": 0.05,
+  "mask_channel_length": 10,
+  "mask_channel_min_space": 1,
+  "mask_channel_other": 0.0,
+  "mask_channel_prob": 0.0,
+  "mask_channel_selection": "static",
+  "mask_feature_length": 10,
+  "mask_feature_prob": 0.0,
+  "mask_time_length": 10,
+  "mask_time_min_space": 1,
+  "mask_time_other": 0.0,
+  "mask_time_prob": 0.05,
+  "mask_time_selection": "static",
+  "model_type": "wav2vec2",
+  "no_mask_channel_overlap": false,
+  "no_mask_time_overlap": false,
+  "num_attention_heads": 12,
+  "num_codevector_groups": 2,
+  "num_codevectors_per_group": 320,
+  "num_conv_pos_embedding_groups": 16,
+  "num_conv_pos_embeddings": 128,
+  "num_feat_extract_layers": 7,
+  "num_hidden_layers": 12,
+  "num_negatives": 100,
+  "pad_token_id": 0,
+  "proj_codevector_dim": 256,
+  "torch_dtype": "float32",
+  "transformers_version": "4.12.0.dev0",
+  "use_weighted_layer_sum": false,
+  "vocab_size": 32
+}

nncf_config.json

@@ -0,0 +1,36 @@
+{
+    "input_info": [
+        {
+            "sample_size": [1, 16000],
+            "type": "float"
+        }
+    ],
+    "compression": {
+        "algorithm": "quantization",
+        "initializer": {
+            "range": {
+                "num_init_samples": 32,
+                "type": "percentile",
+                "params":
+                {
+                    "min_percentile": 0.01,
+                    "max_percentile": 99.99
+                }
+            },
+
+            "batchnorm_adaptation": {
+                "num_bn_adaptation_samples": 200
+            }
+        },
+        "activations":
+        {
+            "mode": "asymmetric"
+        },
+        "weights":
+        {
+            "mode": "symmetric",
+            "signed": true,
+            "per_channel": true
+        }
+    }
+}

ov_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:229e84a458770e5bf4de7dcdcd5e0d55f8bac42287e5c8d2304c123eb08dcb90
+size 95305472

preprocessor_config.json

@@ -0,0 +1,36 @@
+{
+    "input_info": [
+        {
+            "sample_size": [1, 16000],
+            "type": "float"
+        }
+    ],
+    "compression": {
+        "algorithm": "quantization",
+        "initializer": {
+            "range": {
+                "num_init_samples": 32,
+                "type": "percentile",
+                "params":
+                {
+                    "min_percentile": 0.01,
+                    "max_percentile": 99.99
+                }
+            },
+
+            "batchnorm_adaptation": {
+                "num_bn_adaptation_samples": 200
+            }
+        },
+        "activations":
+        {
+            "mode": "asymmetric"
+        },
+        "weights":
+        {
+            "mode": "symmetric",
+            "signed": true,
+            "per_channel": true
+        }
+    }
+}

wav2vec.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""
+ Copyright (C) 2021-2022 Intel Corporation
+
+ 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.
+"""
+
+from argparse import ArgumentParser, SUPPRESS
+from itertools import groupby
+import json
+import logging as log
+from pathlib import Path
+from time import perf_counter
+import sys
+
+import numpy as np
+import wave
+
+from openvino.inference_engine import IECore
+
+ie = IECore()
+
+
+
+class Wav2Vec:
+    alphabet = [
+        "<pad>", "<s>", "</s>", "<unk>", "|",
+        "e", "t", "a", "o", "n", "i", "h", "s", "r", "d", "l", "u",
+        "m", "w", "c", "f", "g", "y", "p", "b", "v", "k", "'", "x", "j", "q", "z"]
+    words_delimiter = '|'
+    pad_token = '<pad>'
+    def __init__(self):
+        self.nnet = ie.read_network("/home/intel/Documents/ASR/wav2vec2-base-ft-keyword-spotting-int8/ov_model.xml", "/home/intel/Documents/ASR/wav2vec2-base-ft-keyword-spotting-int8/ov_model.bin")
+
+    @staticmethod
+    def preprocess(sound):
+        return (sound - np.mean(sound)) / (np.std(sound) + 1e-15)
+
+    def infer(self, audio):
+        exec_net = ie.load_network(self.nnet, "CPU")
+        outss = exec_net.infer({"input_values": audio})
+        # input_data = {next(iter(self.nnet.input_info)): audio}
+        return outss
+
+    def decode(self, logits):
+        token_ids = np.squeeze(np.argmax(logits, -1))
+        tokens = [self.decoding_vocab[idx] for idx in token_ids]
+        tokens = [token_group[0] for token_group in groupby(tokens)]
+        tokens = [t for t in tokens if t != self.pad_token]
+        res_string = ''.join([t if t != self.words_delimiter else ' ' for t in tokens]).strip()
+        res_string = ' '.join(res_string.split(' '))
+        res_string = res_string.lower()
+        return res_string
+
+    def reshape(self, audio):
+        self.nnet.reshape({next(iter(self.nnet.input_info)): audio.shape})
+
+def main():
+    model = Wav2Vec()
+    start_time = perf_counter()
+    with wave.open("/home/intel/Documents/ASR/applications.ai.conversational-ai.asr-grpc-security/client_sample_examples/python/audio_data_samples/how_are_you_doing.wav", 'rb') as wave_read:
+        channel_num, sample_width, sampling_rate, pcm_length, compression_type, _ = wave_read.getparams()
+        assert sample_width == 2, "Only 16-bit WAV PCM supported"
+        assert compression_type == 'NONE', "Only linear PCM WAV files supported"
+        assert channel_num == 1, "Only mono WAV PCM supported"
+        assert sampling_rate == 16000, "Only 16 KHz audio supported"
+        audio = np.frombuffer(wave_read.readframes(pcm_length * channel_num), dtype=np.int16).reshape((1, pcm_length))
+        audio =  audio.astype(float) / np.iinfo(np.int16).max
+
+    normalized_audio = model.preprocess(audio)
+    model.reshape(normalized_audio)
+    character_probs = model.infer(normalized_audio)
+    print(type(character_probs))
+    print(character_probs.keys())
+    transcription = model.decode(character_probs["3761"])
+    total_latency = (perf_counter() - start_time) * 1e3
+    # log.info("Metrics report:")
+    # log.info("\tLatency: {:.1f} ms".format(total_latency))
+    print(transcription)
+    print(total_latency)
+
+if __name__ == '__main__':
+    sys.exit(main() or 0)