sp_diarization.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "sp_diarization.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyN1ZSTWD4sKB7nJNBljkoP5",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/muskang48/Speaker-Diarization/blob/master/sp_diarization.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3afanqemkK3H",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 141
        },
        "outputId": "46c84c64-f033-4c64-f304-cf6d03314d6f"
      },
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n",
            "\n",
            "Enter your authorization code:\n",
            "··········\n",
            "Mounted at /content/drive\n",
            "TensorFlow 1.x selected.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TOWfG0Vs0KZW",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "dfd86a4f-837c-4ae2-fdf0-1a4ebf520c35"
      },
      "source": [
        "#For Installing pyannote from github properly run this and the cell next to this.\n",
        "#Then Restart the runtime and again run both the cells to avoid further errors.\n",
        "pip install typing-extensions==3.7.4.1"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: typing-extensions==3.7.4.1 in /usr/local/lib/python3.6/dist-packages (3.7.4.1)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IS6dRr5d0SQv",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "6d170ba0-4910-48d9-a66d-c2c9ea5fc049"
      },
      "source": [
        "!pip install -q https://github.com/pyannote/pyannote-audio/tarball/develop"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "  Building wheel for pyannote.audio (setup.py) ... \u001b[?25l\u001b[?25hdone\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L5CcYZOLkfhH",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "e0da73f7-b710-4bfe-e532-ad1832c5744b"
      },
      "source": [
        "#Voice Activity Detection\n",
        "!pip install webrtcvad\n",
        "import contextlib\n",
        "import numpy as np\n",
        "import wave\n",
        "import librosa\n",
        "import webrtcvad\n",
        "\n",
        "\n",
        "def read_wave(path):\n",
        "    with contextlib.closing(wave.open(path, 'rb')) as wf:\n",
        "        num_channels = wf.getnchannels()\n",
        "        assert num_channels == 1\n",
        "        sample_width = wf.getsampwidth()\n",
        "        assert sample_width == 2\n",
        "        sample_rate = wf.getframerate()\n",
        "        assert sample_rate in (8000, 16000, 32000, 48000)\n",
        "        pcm_data = wf.readframes(wf.getnframes())\n",
        "        return pcm_data, sample_rate\n",
        "\n",
        "\n",
        "class Frame(object):\n",
        "  def __init__(self, bytes, timestamp, duration):\n",
        "        self.bytes = bytes\n",
        "        self.timestamp = timestamp\n",
        "        self.duration = duration\n",
        "\n",
        "\n",
        "def frame_generator(frame_duration_ms, audio, sample_rate):\n",
        "    n = int(sample_rate * (frame_duration_ms / 1000.0) * 2)\n",
        "    offset = 0\n",
        "    timestamp = 0.0\n",
        "    duration = (float(n) / sample_rate) / 2.0\n",
        "    while offset + n < len(audio):\n",
        "        yield Frame(audio[offset:offset + n], timestamp, duration)\n",
        "        timestamp += duration\n",
        "        offset += n\n",
        "\n",
        "\n",
        "def vad_collector(vad, frames, sample_rate):\n",
        "    is_speech = []\n",
        "    for frame in frames:\n",
        "        is_speech.append(vad.is_speech(frame.bytes, sample_rate))\n",
        "    return is_speech\n",
        "\n",
        "\n",
        "def vad(file):\n",
        "    audio, sample_rate = read_wave(file)\n",
        "    vad = webrtcvad.Vad(2)\n",
        "    frames = frame_generator(10, audio, sample_rate)\n",
        "    frames = list(frames)\n",
        "    segments = vad_collector(vad, frames, sample_rate)\n",
        "    return segments\n",
        "\n",
        "def speech(file):\n",
        "  dummy = 0\n",
        "  data = []\n",
        "  segments = vad(file)\n",
        "  audio, sr = librosa.load(file)\n",
        "  for i in segments:\n",
        "    if i == True:\n",
        "      data.append(audio[dummy:dummy + 480])\n",
        "      dummy = dummy + 480\n",
        "    else:\n",
        "      dummy = dummy + 480\n",
        "  data = np.ravel(np.asarray(data))\n",
        "\n",
        "  return data\n",
        "\n",
        "def fxn(file):\n",
        "  segments = vad(file)\n",
        "  segments = np.asarray(segments)\n",
        "  dummy = 0.01*np.where(segments[:-1] != segments[1:])[0] +.01 \n",
        "  if len(dummy)%2==0:\n",
        "    dummy = dummy\n",
        "  else:\n",
        "    dummy = np.delete(dummy, len(dummy)-1)\n",
        "\n",
        "  voice = dummy.reshape(int(len(dummy)/2),2)\n",
        "  \n",
        "  return voice"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: webrtcvad in /usr/local/lib/python3.6/dist-packages (2.0.10)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hWrP6R8ilaRh",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 436
        },
        "outputId": "db8eef67-696a-42f1-abe8-8dcffcf58f3d"
      },
      "source": [
        "#Segmentation (Each Segment will have only one Speaker)\n",
        "%tensorflow_version 1.x\n",
        "import librosa\n",
        "import matplotlib.pyplot as plt\n",
        "from keras.layers.core import Dense\n",
        "from keras.models import Sequential\n",
        "from keras.layers import Bidirectional, TimeDistributed, Dropout\n",
        "from keras.layers import LSTM\n",
        "import numpy as np\n",
        "import keras\n",
        "\n",
        "model = Sequential()\n",
        "\n",
        "model.add(Bidirectional(LSTM(128, return_sequences=True)))\n",
        "model.add(Bidirectional(LSTM(128, return_sequences=True)))\n",
        "model.add(TimeDistributed(Dense(32)))\n",
        "model.add(TimeDistributed(Dense(32)))\n",
        "model.add(TimeDistributed(Dense(1, activation='sigmoid')))\n",
        "\n",
        "model.build(input_shape=(None, 137, 35))\n",
        "model.summary()\n",
        "#Upload the pre-trained model file from Google Drive. Change the Path accordingly.\n",
        "h5_model_file = '/content/drive/My Drive/SRU/model_hindi_2.h5'\n",
        "model.load_weights(h5_model_file)\n",
        "\n",
        "\n",
        "def multi_segmentation(file):\n",
        "    frame_size = 2048\n",
        "    frame_shift = 512\n",
        "    y, sr = librosa.load(file)\n",
        "    mfccs = librosa.feature.mfcc(y, sr, n_mfcc=12, hop_length=frame_shift, n_fft=frame_size)\n",
        "    mfcc_delta = librosa.feature.delta(mfccs)\n",
        "    mfcc_delta2 = librosa.feature.delta(mfccs, order=2)\n",
        "\n",
        "    mfcc = mfccs[1:, ]\n",
        "    norm_mfcc = (mfcc - np.mean(mfcc, axis=1, keepdims=True)) / np.std(mfcc, axis=1, keepdims=True)\n",
        "    norm_mfcc_delta = (mfcc_delta - np.mean(mfcc_delta, axis=1, keepdims=True)) / np.std(mfcc_delta, axis=1, keepdims=True)\n",
        "    norm_mfcc_delta2 = (mfcc_delta2 - np.mean(mfcc_delta2, axis=1, keepdims=True)) / np.std(mfcc_delta2, axis=1, keepdims=True)\n",
        "\n",
        "    ac_feature = np.vstack((norm_mfcc, norm_mfcc_delta, norm_mfcc_delta2))\n",
        "    print(ac_feature.shape)\n",
        "\n",
        "    sub_seq_len = int(3.2 * sr / frame_shift)\n",
        "    sub_seq_step = int(0.8 * sr / frame_shift)\n",
        "\n",
        "    def extract_feature():\n",
        "        feature_len = ac_feature.shape[1]\n",
        "        sub_train_x = []\n",
        "        for i in range(0, feature_len-sub_seq_len, sub_seq_step):\n",
        "            sub_seq_x = np.transpose(ac_feature[:, i: i+sub_seq_len])\n",
        "            sub_train_x.append(sub_seq_x[np.newaxis, :, :])\n",
        "        return np.vstack(sub_train_x), feature_len\n",
        "\n",
        "    predict_x, feature_len = extract_feature()\n",
        "    print(predict_x.shape)\n",
        "\n",
        "    predict_y = model.predict(predict_x)\n",
        "    print(predict_y.shape)\n",
        "\n",
        "    score_acc = np.zeros((feature_len, 1))\n",
        "    score_cnt = np.ones((feature_len, 1))\n",
        "\n",
        "    for i in range(predict_y.shape[0]):\n",
        "        for j in range(predict_y.shape[1]):\n",
        "            index = i*sub_seq_step+j\n",
        "            score_acc[index] += predict_y[i, j, 0]\n",
        "            score_cnt[index] += 1\n",
        "\n",
        "    score_norm = score_acc / score_cnt\n",
        "\n",
        "    wStart = 0\n",
        "    wEnd = 200\n",
        "    wGrow = 200\n",
        "    delta = 25\n",
        "\n",
        "    store_cp = []\n",
        "    index = 0\n",
        "    while wEnd < feature_len:\n",
        "        score_seg = score_norm[wStart:wEnd]\n",
        "        max_v = np.max(score_seg)\n",
        "        max_index = np.argmax(score_seg)\n",
        "        index = index + 1\n",
        "        if max_v > 0.5:\n",
        "            temp = wStart + max_index\n",
        "            store_cp.append(temp)\n",
        "            wStart = wStart + max_index + 50\n",
        "            wEnd = wStart + wGrow\n",
        "        else:\n",
        "            wEnd = wEnd + wGrow\n",
        "\n",
        "    seg_point = np.array(store_cp)*frame_shift\n",
        "\n",
        "    plt.figure('speech segmentation plot')\n",
        "    plt.plot(np.arange(0, len(y)) / (float)(sr), y, \"b-\")\n",
        "\n",
        "    for i in range(len(seg_point)):\n",
        "        plt.vlines(seg_point[i] / (float)(sr), -1, 1, colors=\"c\", linestyles=\"dashed\")\n",
        "        plt.vlines(seg_point[i] / (float)(sr), -1, 1, colors=\"r\", linestyles=\"dashed\")\n",
        "    plt.xlabel(\"Time/s\")\n",
        "    plt.ylabel(\"Speech Amp\")\n",
        "    plt.grid(True)\n",
        "    plt.show()\n",
        "\n",
        "    return np.asarray(seg_point) / float(sr)"
      ],
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "TensorFlow 1.x selected.\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "Using TensorFlow backend.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From /tensorflow-1.15.2/python3.6/tensorflow_core/python/ops/resource_variable_ops.py:1630: calling BaseResourceVariable.__init__ (from tensorflow.python.ops.resource_variable_ops) with constraint is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "If using Keras pass *_constraint arguments to layers.\n",
            "Model: \"sequential_1\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "bidirectional_1 (Bidirection (None, 137, 256)          167936    \n",
            "_________________________________________________________________\n",
            "bidirectional_2 (Bidirection (None, 137, 256)          394240    \n",
            "_________________________________________________________________\n",
            "time_distributed_1 (TimeDist (None, 137, 32)           8224      \n",
            "_________________________________________________________________\n",
            "time_distributed_2 (TimeDist (None, 137, 32)           1056      \n",
            "_________________________________________________________________\n",
            "time_distributed_3 (TimeDist (None, 137, 1)            33        \n",
            "=================================================================\n",
            "Total params: 571,489\n",
            "Trainable params: 571,489\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "onC8jO7Tl99E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Re-segmentation (Based on Combining VAD and Segementation Output)\n",
        "def group_intervals(a):\n",
        "    a = a.tolist()\n",
        "    ans = []\n",
        "\n",
        "    curr = None\n",
        "    for x in a:\n",
        "        # no previous interval under consideration\n",
        "        if curr == None:\n",
        "          curr = x\n",
        "        else:\n",
        "            # check if we can merge the intervals\n",
        "            if x[0]-curr[1] < 1:\n",
        "                curr[1] = x[1]\n",
        "            else:\n",
        "            # if we cannot merge, push the current element to ans\n",
        "                ans.append(curr)\n",
        "                curr = x\n",
        "\n",
        "        if curr is not None:\n",
        "            ans.append(curr)\n",
        "\n",
        "    d1 = np.asarray(ans)\n",
        "    d2 = np.unique(d1)\n",
        "    d3 = d2.reshape(int(len(d2)/2),2)\n",
        "    return d3\n",
        "    \n",
        "def spliting(seg,arr):\n",
        "  arr1 = arr.tolist()\n",
        "  temp = arr.copy()\n",
        "  \n",
        "  for i in range(len(seg)-1):\n",
        "    temp1 = float(seg[i])\n",
        "    # print(temp1)\n",
        "    #for j in range(len(arr)-1):\n",
        "    for j in range(len(arr)):\n",
        "      if ((temp1 > arr[j][0]) & (temp1 < arr[j][1])):\n",
        "        arr1[j].insert(-1,(temp1))\n",
        "\n",
        "  #for i in range(len(arr1-1)):\n",
        "  for i in range(len(arr1)):\n",
        "    size=len(arr1[i])\n",
        "    if size>=3:\n",
        "      arr1[i].pop(-2) if arr1[i][-1]-arr1[i][-2]<0.2 else True\n",
        "      \n",
        "  return arr1\n",
        "  \n",
        "def final_reseg(arr):\n",
        "  z=[]\n",
        "  for i in arr:\n",
        "    if len(i)==2:\n",
        "      z.append(i)\n",
        "    else:\n",
        "      temp = len(i)\n",
        "      for j in range(temp-1):\n",
        "        if j!=temp-1:\n",
        "          temp1 = [i[j],i[j+1]-0.01]\n",
        "          z.append(temp1)\n",
        "        elif j==temp-1:\n",
        "          temp1 = [i[j],i[j+1]]\n",
        "          z.append(temp1)\n",
        "  \n",
        "  return np.asarray(z)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J1JdDad7ndpk",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Embedding Extraction\n",
        "import torch\n",
        "import librosa\n",
        "from pyannote.core import Segment\n",
        "\n",
        "def embeddings_(audio_path,resegmented,range):\n",
        "  model_emb = torch.hub.load('pyannote/pyannote-audio', 'emb')\n",
        "  \n",
        "  embedding = model_emb({'audio': audio_path})\n",
        "  for window, emb in embedding:\n",
        "    assert isinstance(window, Segment)\n",
        "    assert isinstance(emb, np.ndarray)\n",
        "\n",
        "  y, sr = librosa.load(audio_path)\n",
        "  myDict={}\n",
        "  myDict['audio'] = audio_path\n",
        "  myDict['duration'] = len(y)/sr\n",
        "\n",
        "  data=[]\n",
        "  for i in resegmented:\n",
        "    excerpt = Segment(start=i[0], end=i[0]+range)\n",
        "    emb = model_emb.crop(myDict,excerpt)\n",
        "    data.append(emb.T)\n",
        "  data= np.asarray(data)\n",
        "  \n",
        "  return data.reshape(len(data),512)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wc2APlNsom2b",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Clustering (Mean-Shift)\n",
        "from sklearn.manifold import TSNE\n",
        "from sklearn.cluster import MeanShift\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "import matplotlib.pyplot as plt\n",
        "scaler = StandardScaler()\n",
        "def clustering(emb):\n",
        "  temp = scaler.fit_transform(emb)\n",
        "  Y = TSNE(n_components=2).fit_transform(temp)\n",
        "  cluster_ms = MeanShift(bandwidth = 3,max_iter='200',cluster_all=False).fit(Y)\n",
        "  y_ms = cluster_ms.predict(Y)\n",
        "  clus_centre = cluster_ms.cluster_centers_\n",
        "  n_speakers = clus_centre.shape[0]\n",
        "  plt.figure\n",
        "  plt.scatter(Y[:,0], Y[:, 1], c=y_ms, s=50, cmap='viridis')\n",
        "  plt.show()\n",
        "\n",
        "  return y_ms, n_speakers"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3EjVUubjpB-w",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Generating Hypothesis\n",
        "from pyannote.core import Annotation, Segment\n",
        "def hypothesis_gen(hyp_df):\n",
        "  hyp_records = hyp_df.to_records(index=False)\n",
        "  hyp_rec = list(hyp_records)\n",
        "  hypothesis = Annotation()\n",
        "  for i in range(len(hyp_rec)-1):\n",
        "    hypothesis[Segment(hyp_rec[i][1], hyp_rec[i][2])] = hyp_rec[i][0]\n",
        "\n",
        "  return hypothesis"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aKLzU1mVpKyZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Diarization \n",
        "from sklearn import preprocessing\n",
        "import pandas as pd\n",
        "def diarization(audiofile):\n",
        "    voice = fxn(audiofile)\n",
        "    segmented = multi_segmentation(audiofile)\n",
        "    gp = group_intervals(voice)\n",
        "    splt = spliting(segmented,gp)\n",
        "    resegmented = final_reseg(splt)\n",
        "    embeddings = embeddings_(audiofile,resegmented,2)\n",
        "    speak_id , n_speakers = clustering(embeddings)\n",
        "    label_list = []\n",
        "    alpha = 'A'\n",
        "    for i in range(0, n_speakers): \n",
        "        label_list.append(alpha) \n",
        "        alpha = chr(ord(alpha) + 1) \n",
        "    lb = preprocessing.LabelEncoder()\n",
        "    label_hyp = lb.fit(label_list)\n",
        "    speaker_id = lb.inverse_transform(speak_id)\n",
        "    hyp_df = pd.DataFrame({'Speaker_id': speaker_id,'Offset': resegmented[:, 0], 'end': resegmented[:, 1]})\n",
        "    result_hypo = hypothesis_gen(hyp_df)  \n",
        "    return segmented, n_speakers, hyp_df, result_hypo"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T17SeN1Hw__b",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 666
        },
        "outputId": "fc9ee8a5-0e96-43bf-cf32-4106cbd24fb5"
      },
      "source": [
        "#Give the path of audio file for Speaker Diarization (It should be Mono type.)\n",
        "segmented, n_clusters, hyp_df, result_hypo = diarization('/content/drive/My Drive/SRU/Hindi_01.wav')\n",
        "print(n_clusters)\n",
        "print(hyp_df)\n",
        "result_hypo"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "(35, 78497)\n",
            "(2305, 137, 35)\n",
            "(2305, 137, 1)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "Using cache found in /root/.cache/torch/hub/pyannote_pyannote-audio_master\n",
            "/usr/local/lib/python3.6/dist-packages/pyannote/audio/embedding/approaches/arcface_loss.py:170: FutureWarning:\n",
            "\n",
            "The 's' parameter is deprecated in favor of 'scale', and will be removed in a future release\n",
            "\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab_type": "code",
        "id": "mMRwTnjJyu7A",
        "colab": {}
      },
      "source": [
        "#Evaluation (DER)\n",
        "def reference_gen(annotation_path):\n",
        "  df = pd.read_csv(annotation_path)\n",
        "  ref_df = df[df['filename'] == 'Hindi_01']\n",
        "  ref_df = ref_df.assign(end = ref_df.Offset + ref_df.Duration)\n",
        "  ref_df = ref_df[['Speaker_id','Offset','end']]\n",
        "  ref_records = ref_df.to_records(index=False)\n",
        "  ref_rec = list(ref_records)\n",
        "  reference = Annotation()\n",
        "  for i in range(len(ref_rec)-1):\n",
        "    reference[Segment(ref_rec[i][1], ref_rec[i][2])] = ref_rec[i][0]\n",
        "\n",
        "  return reference, ref_df"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ooGFwg2cx96R",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 159
        },
        "outputId": "d8cca564-9ec2-4d85-a10d-450cfa0e1151"
      },
      "source": [
        "#Give the path for Annotations File of Audio for calculating DER.\n",
        "reference, ref_df = reference_gen('/content/drive/My Drive/SRU/hindi_annotations1.csv')\n",
        "#Visualization (Comparing Between Ground Truth and Hypothesis)\n",
        "reference"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<pyannote.core.annotation.Annotation at 0x7fb615e49e10>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0L85ga_d9U4s",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 159
        },
        "outputId": "634f5696-852b-469c-d242-486ac5b1e2ba"
      },
      "source": [
        "result_hypo"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<pyannote.core.annotation.Annotation at 0x7fb61d020080>"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4eWYkbK8v1Bg",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 139
        },
        "outputId": "6c09c6ee-5ab6-4aab-99b3-d67952aba752"
      },
      "source": [
        "from pyannote.metrics.diarization import DiarizationErrorRate\n",
        "from pyannote.metrics.diarization import DiarizationPurity\n",
        "from pyannote.metrics.diarization import DiarizationCoverage\n",
        "#Upload the annotation file from Google Drive. Change the Path accordingly.\n",
        "result_ref, ref_df = reference_gen('/content/drive/My Drive/SRU/hindi_annotations1.csv')\n",
        "diarizationErrorRate = DiarizationErrorRate()\n",
        "print(\"DER = {0:.3f}\".format(diarizationErrorRate(result_ref, result_hypo)))\n",
        "#To Evaluate particular Segment of audio-file.\n",
        "diarizationErrorRate(result_ref, result_hypo, detailed=True, uem=Segment(0, 40))\n",
        "#Purity \n",
        "purity = DiarizationPurity()\n",
        "print(\"Purity = {0:.3f}\".format(purity(result_ref, result_hypo, uem=Segment(0, 40))))\n",
        "#Coverage\n",
        "coverage = DiarizationCoverage()\n",
        "print(\"Coverage = {0:.3f}\".format(coverage(result_ref, result_hypo, uem=Segment(0, 40))))"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "DER = 0.267\n",
            "Purity = 1.000\n",
            "Coverage = 0.645\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/pyannote/metrics/utils.py:184: UserWarning:\n",
            "\n",
            "'uem' was approximated by the union of 'reference' and 'hypothesis' extents.\n",
            "\n"
          ],
          "name": "stderr"
        }
      ]
    }
  ]
}