data_augmentation_with_python_chapter_7.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/duchaba/Data-Augmentation-with-Python/blob/main/data_augmentation_with_python_chapter_7.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 🌻 Welcome to Chapter 7, Audio Data Augmentation\n",
        "\n",
        "---\n",
        "\n",
        "I am glad to see you using this Python Notebook. 🐕\n",
        "\n",
        "The Python Notebook is an integral part of the book. You can add new “code cells” to extend the functions, add your data, and explore new possibilities, such as downloading additional real-world datasets from the Kaggle website and coding the **Fun challenges**. Furthermore, the book has **Fun facts**, in-depth discussion about augmentation techniques, and Pluto, an imaginary Siberian Huskey coding companion. Together they will guide you every steps of the way.\n",
        "\n",
        "Pluto encourages you to copy or save a copy of this Python Notebook to your local space and add the “text cells” to keep your notes. In other words, read the book and copy the relevant concept to this Python Notebook’s text-cells. Thus, you can have the explanation, note, original code, your code, and any crazy future ideas in one place.  \n",
        "\n",
        "\n",
        "💗 I hope you enjoy reading the book and hacking code as much as I enjoy writing it.\n",
        "\n",
        "\n",
        "## 🌟 Amazon Book\n",
        "\n",
        "---\n",
        "\n",
        "- The book is available on the Amazon Book website:\n",
        "  - https://www.amazon.com/dp/1803246456\n",
        "\n",
        "  - Author: Duc Haba\n",
        "  - Published: 2023\n",
        "  - Page count: 390+\n",
        "\n",
        "\n",
        "- The original Python Notebook is on:\n",
        "  - https://github.com/PacktPublishing/Data-Augmentation-with-Python/blob/main/Chapter_7/data_augmentation_with_python_chapter_7.ipynb\n",
        "\n",
        "- 🚀 Click on the blue \"Open in Colab\" button at the top of this page to begin hacking.\n"
      ],
      "metadata": {
        "id": "1DlWAB8G4ijz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 😀 Excerpt from Chapter 7, Audio Data Augmentation\n",
        "\n",
        "---\n",
        "\n",
        "> In case you haven’t bought the book. Here is an teaser from the first page of Chapter 7.\n",
        "\n",
        "---\n",
        "\n",
        "Similar to image and text augmentation, the objective of audio data augmentation is to extend the dataset to gain a higher accuracy forecast or prediction in a generative AI system. Audio augmentation is cost-effective and is a viable option when acquiring additional audio files is expensive or time-consuming.  \n",
        "\n",
        "Writing about audio augmentation methods poses unique challenges. The first is that audio is not visual like images or text. If the format is audiobooks, web pages, or mobile apps, then we play the sound, but the medium is paper. Thus, we must transform the audio signal into a visual representation. The Waveform graph, also known as the time series graph, is a standard method for representing an audio signal. You can listen to the audio in the accompanying Python Notebook.\n",
        "\n",
        "In this chapter, you will learn how to write Python code to read an audio file and draw a Waveform graph from scratch. Pluto has provided a preview here so that we can discuss the components of the Waveform graph. The function is as follows:\n",
        "\n",
        "> ...skip...image...\n",
        "\n",
        "In Figure 7.1, Pluto drew the positive amplitude in blue and the negative amplitude in yellow in the Waveform graph. This makes the chart easier to read and prettier. The amplitude is the value of the Y-axis. It measures the vibration or compression and decompression of the air molecules. The higher the amplitude, the greater the air displacement. In other words, the zero amplitude value is silent, and the greater the absolute distance from zero, the louder the sound.\n",
        "\n",
        "The frequency, also known as the sampling rate, is the value of the X-axis. The sampling rate measures how many times you recorded the amplitude value in a second. The unit for sound frequency or the sampling rate is hertz (Hz). For example, a sampling rate of 1,000 Hz or 1 kilohertz (kHz) means you record a thousand amplitude values in 1 second. In other words, you register an amplitude value for every millisecond. Thus, the higher the frequency, the more accurate the sound, and therefore, a larger sound file size. This is because there is a higher recorded amplitude value. 1 kHz is equal to 1,000 Hz.\n",
        "\n",
        "Pitch is the same as frequency but from a human point of view. It refers to the loudness of the sound and is measured in decibels (dB). Thus, high pitch means high frequency.\n",
        "\n",
        "dB is the unit for the degree of loudness. A rocket sound is about 165 dB, busy traffic noise is about 85 dB, human speech is about 65 dB, rainfall is about 45 dB, and zero dB means silence.\n",
        "\n",
        "The standard sampling rate for MP3 and other audio formats is 22.05 kHz. The frequency of high-quality sound, also known as Compact Disk (CD) sound, is 44.1 kHz.\n",
        "\n",
        "When storing an audio file on a computer, bit depth is the accuracy of the amplitude value. 16 bits has 65,536 levels of detail, while 24 bits has 16,777,216 levels of information. The higher the bit depth, the closer the digital recording is to the analog sound and the larger the audio file size.  \n",
        "\n",
        "The bit rate is similar to the sampling rate, where the bit rate measures the number of bits per second. In audio processing, the playback function uses the bit rate, while the record function uses the sampling rate.\n",
        "\n",
        "Mono sound has one channel (1-channel), while stereo sound has two channels (2-channel). Stereo sound has one channel for the right ear and another channel for the left ear.\n",
        "\n",
        "> ...skip...skip...\n",
        "\n",
        "This chapter will cover audio augmentation using Waveform transformation, and in particular, the following topics:   \n",
        "\n",
        "- Standard audio augmentation techniques\n",
        "\n",
        "- Filters\n",
        "\n",
        "- Audio augmentation libraries\n",
        "\n",
        "- Real-world audio datasets  \n",
        "\n",
        "- Reinforcing your learning through Python Notebook\n",
        "\n",
        "Let’s begin by discussing common audio augmentation methods.\n",
        "\n",
        "---\n",
        "\n",
        "🌴 *end of excerpt from the book*"
      ],
      "metadata": {
        "id": "Txu_FlOsPsDs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Load Notebook\n"
      ],
      "metadata": {
        "id": "ZZ8-JIXv6jmV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- This Notebook original link is:\n",
        "  - https://github.com/PacktPublishing/Data-Augmentation-with-Python/blob/main/data_augmentation_with_python_chapter_7.ipynb"
      ],
      "metadata": {
        "id": "dOpu3yYb6rK_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# GitHub Clone"
      ],
      "metadata": {
        "id": "4b52gSlp60SN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# git version should be 2.17.1 or higher\n",
        "!git --version"
      ],
      "metadata": {
        "id": "6oeDAu1u6zWf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "url = 'https://github.com/PacktPublishing/Data-Augmentation-with-Python'\n",
        "!git clone {url}"
      ],
      "metadata": {
        "id": "J9buwUR767Te"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Fetch file from URL (Optional)\n",
        "\n",
        "- Uncommend the below 2 code cells if you want to use URL and not Git Clone"
      ],
      "metadata": {
        "id": "lOawA01L7Ok0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# import requests\n",
        "# #\n",
        "# def fetch_file(url, dst):\n",
        "#   downloaded_obj = requests.get(url)\n",
        "#   with open(dst, \"wb\") as file:\n",
        "#     file.write(downloaded_obj.content)\n",
        "#   return"
      ],
      "metadata": {
        "id": "HsmQ7rgj67Ww"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# url = ''\n",
        "# dst = 'pluto_chapter_1.py'\n",
        "# fetch_file(url,dst)"
      ],
      "metadata": {
        "id": "_nKp0nxT67aH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Run Pluto\n",
        "\n",
        "- Instantiate up Pluto, aka. \"Pluto, wake up!\""
      ],
      "metadata": {
        "id": "6462KTtr7cFQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %% CARRY-OVER code install\n",
        "\n",
        "!pip install opendatasets\n",
        "!pip install pyspellchecker\n",
        "\n",
        "# The tested version:\n",
        "# opendatasets==0.1.12\n",
        "# pyspellchecker==0.7.1\n",
        "#\n",
        "# if error with newer version, then install:\n",
        "# !pip install opendatasets==0.1.12\n",
        "# !pip install pyspellchecker==0.7.1"
      ],
      "metadata": {
        "id": "jCGiTw16ZxVH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#load and run the pluto chapter 1 Python code.\n",
        "pluto_file = 'Data-Augmentation-with-Python/pluto/pluto_chapter_2.py'\n",
        "%run {pluto_file}"
      ],
      "metadata": {
        "id": "u3zbkOO86_WB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Verify Pluto"
      ],
      "metadata": {
        "id": "yhRR0JSf746h"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.say_sys_info()"
      ],
      "metadata": {
        "id": "nBIw7fiI6_Zy"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## (Optional) Export to .py"
      ],
      "metadata": {
        "id": "LaURlsasaGuo"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pluto_chapter_7 = 'Data-Augmentation-with-Python/pluto/pluto_chapter_7.py'\n",
        "!cp {pluto_file} {pluto_chapter_7}"
      ],
      "metadata": {
        "id": "Gfx9Ai5Opyqp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# ✋ Set up Kaggle username and app Key\n",
        "\n",
        "- Install the following libraries, and import it on the Notebook.\n",
        "- Follow by initialize Kaggle username, key and fetch methods.\n",
        "\n",
        "- STOP: Update your Kaggle access username or key first."
      ],
      "metadata": {
        "id": "kQ6ap39x8HyF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %%CARRY-OVER code\n",
        "\n",
        "# -------------------- : --------------------\n",
        "# READ ME\n",
        "# Chapter 2 begin:\n",
        "# Install the following libraries, and import it on the Notebook.\n",
        "# Follow by initialize Kaggle username, key and fetch methods.\n",
        "# STOP: Update your Kaggle access username or key first.\n",
        "# -------------------- : --------------------\n",
        "\n",
        "!pip install opendatasets --upgrade\n",
        "import opendatasets\n",
        "print(\"\\nrequired version 0.1.22 or higher: \", opendatasets.__version__)\n",
        "\n",
        "!pip install pyspellchecker\n",
        "import spellchecker\n",
        "print(\"\\nRequired version 0.7+\", spellchecker.__version__)\n",
        "\n",
        "# STOP: Update your Kaggle access username or key first.\n",
        "pluto.remember_kaggle_access_keys(\"YOUR-USERNAME\", \"YOUR-KEY\")\n",
        "pluto._write_kaggle_credit()\n",
        "import kaggle\n",
        "\n",
        "@add_method(PacktDataAug)\n",
        "def fetch_kaggle_comp_data(self,cname):\n",
        "  #self._write_kaggle_credit()  # need to run only once.\n",
        "  path = pathlib.Path(cname)\n",
        "  kaggle.api.competition_download_cli(str(path))\n",
        "  zipfile.ZipFile(f'{path}.zip').extractall(path)\n",
        "  return\n",
        "\n",
        "@add_method(PacktDataAug)\n",
        "def fetch_kaggle_dataset(self,url,dest=\"kaggle\"):\n",
        "  #self._write_kaggle_credit()    # need to run only once.\n",
        "  opendatasets.download(url,data_dir=dest)\n",
        "  return\n",
        "# -------------------- : --------------------\n"
      ],
      "metadata": {
        "id": "sf4Obdp-77CL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fetch Kaggle Data"
      ],
      "metadata": {
        "id": "5BfHiMQE8XWp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Musical Emotions Classification"
      ],
      "metadata": {
        "id": "WSWTfhPU9YjQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "url = 'https://www.kaggle.com/datasets/kingofarmy/musical-emotions-classification'\n",
        "pluto.fetch_kaggle_dataset(url)"
      ],
      "metadata": {
        "id": "_TEFhsYs77Go"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "f = 'kaggle/musical-emotions-classification/Train.csv'\n",
        "pluto.df_music_data = pluto.fetch_df(f)\n",
        "pluto.df_music_data.head(3)"
      ],
      "metadata": {
        "id": "_GHi9DnM77Kj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "pluto.version = 7.0\n",
        "# augment full path\n",
        "@add_method(PacktDataAug)\n",
        "def _append_music_full_path(self,x):\n",
        "\n",
        "  \"\"\"\n",
        "  Append the full path of the music file to the dataframe.\n",
        "\n",
        "  Args:\n",
        "    x: A string containing the name of the music file.\n",
        "\n",
        "  Returns:\n",
        "    A string containing the full path of the music file.\n",
        "  \"\"\"\n",
        "\n",
        "  y = re.findall('([a-zA-Z ]*)\\d*.*', x)[0]\n",
        "  return (f'kaggle/musical-emotions-classification/Audio_Files/Audio_Files/Train/{y}/{x}')\n",
        "#\n",
        "@add_method(PacktDataAug)\n",
        "def fetch_music_full_path(self, df):\n",
        "\n",
        "  \"\"\"\n",
        "  Append the full path of the music file to the dataframe.\n",
        "\n",
        "  Args:\n",
        "    df: A pandas dataframe containing the music file names.\n",
        "\n",
        "  Returns:\n",
        "    A pandas dataframe with the full path of the music files appended.\n",
        "  \"\"\"\n",
        "\n",
        "  df['fname'] = df.ImageID.apply(self._append_music_full_path)\n",
        "  return df"
      ],
      "metadata": {
        "id": "5zK1p7UBJoEW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.fetch_music_full_path(pluto.df_music_data)\n",
        "pluto.df_music_data.head(3)"
      ],
      "metadata": {
        "id": "M1Q_FAadP-Wm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Human Speech"
      ],
      "metadata": {
        "id": "5TDs0Iz0RCXb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "url = 'https://www.kaggle.com/datasets/ejlok1/cremad'\n",
        "pluto.fetch_kaggle_dataset(url)"
      ],
      "metadata": {
        "id": "Q9o4H58gRBcO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#\n",
        "# change method name to make_dir_dframe\n",
        "f = 'kaggle/cremad/AudioWAV'\n",
        "pluto.df_voice_data = pluto.make_dir_dataframe(f)\n",
        "pluto.df_voice_data.head(3)"
      ],
      "metadata": {
        "id": "3zq3-nbPOFoG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Urban sound"
      ],
      "metadata": {
        "id": "0kxU64ydU4Js"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "url = 'https://www.kaggle.com/datasets/rupakroy/urban-sound-8k'\n",
        "pluto.fetch_kaggle_dataset(url)"
      ],
      "metadata": {
        "id": "NUGSqM4wUaDH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#\n",
        "# change method name to make_dir_dframe\n",
        "f = 'kaggle/urban-sound-8k/UrbanSound8K/UrbanSound8K/audio'\n",
        "pluto.df_sound_data = pluto.make_dir_dataframe(f)\n",
        "pluto.df_sound_data.head(3)"
      ],
      "metadata": {
        "id": "ry1HB_qDUaGv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# View and Listen"
      ],
      "metadata": {
        "id": "VaB7rJ4IgL_E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# to-do: there is a deprecated function with version 0.10.0 (Feb. 2023)\n",
        "!pip install librosa==0.9.2"
      ],
      "metadata": {
        "id": "Fyk7122gLYIH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "import IPython\n",
        "import IPython.display\n",
        "import librosa\n",
        "import librosa.display\n",
        "import matplotlib\n",
        "import pandas\n",
        "import numpy\n",
        "import re"
      ],
      "metadata": {
        "id": "VbrcB_i5gd7A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "# prompt: write inline documentation with default value and type for the following python function: _draw_area_with_neg()\n",
        "@add_method(PacktDataAug)\n",
        "def _draw_area_with_neg(self,ndata,pic,tcolor='#007bff',bcolor='#ffc107',alpha=0.75,istart=0,izero=0):\n",
        "\n",
        "  \"\"\"\n",
        "  Draw a positive/negative area with a line chart.\n",
        "\n",
        "  Args:\n",
        "    ndata: (numpy array) A numpy array containing the data to be plotted.\n",
        "    pic: (figure) A matplotlib.pyplot.Figure object to draw the plot on.\n",
        "    tcolor: (str) The color of the positive area. Default is '#007bff'\n",
        "    bcolor: (str) The color of the negative area. Default is '#ffc107'\n",
        "    alpha: (float) The transparency of the areas. Default is 0.75\n",
        "    istart: (int) The starting index of the data to be plotted. Default is zero.\n",
        "    izero: (int) The zero value of the data. Default is zero.\n",
        "\n",
        "  Returns:\n",
        "    None.\n",
        "  \"\"\"\n",
        "\n",
        "  nlen = len(ndata)\n",
        "  i = numpy.arange(istart, istart+nlen)\n",
        "  xzero = numpy.zeros(nlen)\n",
        "  xzero += izero\n",
        "  # plot line\n",
        "  pic.plot(i,ndata, linewidth=0.0)  # invisible line for shading\n",
        "  pic.plot(i,xzero,color='gray',linewidth=0.5) # base line\n",
        "\n",
        "  # fill top/positive section\n",
        "  pic.fill_between(\n",
        "    i, xzero, ndata, where=(ndata >= xzero),\n",
        "    interpolate=True, color=tcolor, alpha=alpha,\n",
        "    label=\"Positive\"\n",
        "  )\n",
        "  # fill bottom/negative section\n",
        "  pic.fill_between(\n",
        "    i, xzero, ndata, where=(ndata < xzero),\n",
        "    interpolate=True, color=bcolor, alpha=alpha,\n",
        "    label=\"Negative\"\n",
        "  )\n",
        "  return\n",
        "#\n",
        "# prompt: write inline documentation with default value and type for the following python function: _fetch_audio_data()\n",
        "@add_method(PacktDataAug)\n",
        "def _fetch_audio_data(self,lname):\n",
        "\n",
        "  \"\"\"\n",
        "  Fetch audio data from a file name.\n",
        "\n",
        "  Args:\n",
        "    lname: (str) The file name of the audio file.\n",
        "\n",
        "  Returns:\n",
        "    (tuple) A tuple containing the audio data, the sampling rate, and the file name.\n",
        "  \"\"\"\n",
        "\n",
        "  data_amp, sam_rate = librosa.load(lname, mono=True)\n",
        "  fname = re.findall('[^\\/]+$', lname)\n",
        "  return data_amp, sam_rate, fname[0]\n",
        "#\n",
        "# prompt: write inline documentation with default value and type for the following python function: _draw_audio()\n",
        "@add_method(PacktDataAug)\n",
        "def _draw_audio(self,data_amp, sam_rate, fname):\n",
        "\n",
        "  \"\"\"\n",
        "  Draw audio waveform.\n",
        "\n",
        "  Args:\n",
        "    data_amp (numpy array): , 1 dimensional.\n",
        "    sam_rate (integer): sampling rate.\n",
        "    fname: string): name of the output file.\n",
        "\n",
        "  Return:\n",
        "    None\n",
        "  \"\"\"\n",
        "\n",
        "  # define constant\n",
        "  zlen = 100\n",
        "  nrow = 2\n",
        "  ncol = 1\n",
        "  w = 11\n",
        "  h = 6\n",
        "  title = ['', 'Zoom In: From Midpoint to 100+']\n",
        "  ylabel = ['Waveform Amplitude']\n",
        "  #\n",
        "  # define graph\n",
        "  canvas, pic = matplotlib.pyplot.subplots(nrow, ncol, figsize=(w, h))\n",
        "  pics = pic.flatten()\n",
        "  # draw original\n",
        "  dlen = len(data_amp)\n",
        "  self._draw_area_with_neg(data_amp,pic[0])\n",
        "  pics[0].set_title(f'{title[0]} {fname}', fontsize=18.)\n",
        "  pics[0].set_xlabel(f'Second: Total {dlen/sam_rate:.2f} sec., Sampling Rate: {sam_rate/1000:.2f} kHz', fontsize=16.)\n",
        "  pics[0].set_ylabel(ylabel[0])\n",
        "  #\n",
        "  # overide tick with time\n",
        "  loc = numpy.array(pics[0].get_xticks())\n",
        "  b = loc / sam_rate\n",
        "  b = numpy.round(b,1)\n",
        "  pics[0].set_xticklabels(b)\n",
        "  pics[0].grid()\n",
        "  #\n",
        "  # draw zoom\n",
        "  mid = int(len(data_amp) / 2)\n",
        "  end = mid + zlen\n",
        "  self._draw_area_with_neg(data_amp[mid:end],pic[1])\n",
        "  pics[1].set_title(title[1],fontsize=18.)\n",
        "  pics[1].set_xlabel(f'Time Series Index: Midpoint at {mid/sam_rate:.2f} sec. ({mid} ts)', fontsize=16.)\n",
        "  pics[1].set_ylabel(ylabel[0])\n",
        "  pics[1].grid()\n",
        "  #\n",
        "  # display and save image\n",
        "  canvas.tight_layout()\n",
        "  self._drop_image(canvas)\n",
        "  canvas.show()\n",
        "  #\n",
        "  return\n",
        "#\n",
        "# prompt: write inline documentation with default value and type for the following python function: draw_audio()\n",
        "@add_method(PacktDataAug)\n",
        "def draw_audio(self,df,id_name=None):\n",
        "\n",
        "  \"\"\"\n",
        "  Draw audio waveform.\n",
        "\n",
        "  Args:\n",
        "    df: (pandas DataFrame): with column 'fname' that contains the file name of\n",
        "      each audio file.\n",
        "    id_name (string): file name of the audio file to draw. If None, a random\n",
        "      file name will be drawn.\n",
        "\n",
        "  Returns:\n",
        "    None.\n",
        "  \"\"\"\n",
        "  # random take a file name\n",
        "  if (id_name is None):\n",
        "    samp = df.sample(1)\n",
        "    samp.reset_index(drop=True, inplace=True)\n",
        "    in_file = samp.fname[0]\n",
        "  else:\n",
        "    in_file = id_name\n",
        "  #\n",
        "  data_amp, sam_rate, fname = self._fetch_audio_data(in_file)\n",
        "  self._draw_audio(data_amp, sam_rate, 'Original: ' + fname)\n",
        "  # display audio\n",
        "  display(IPython.display.Audio(data_amp,rate=sam_rate))\n",
        "  return\n",
        "#"
      ],
      "metadata": {
        "id": "jeC4EsXlaFc9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.draw_audio(pluto.df_music_data)"
      ],
      "metadata": {
        "id": "19TFbZJEq-4X"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.draw_audio(pluto.df_voice_data)"
      ],
      "metadata": {
        "id": "GxEjwIfNsHik"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.draw_audio(pluto.df_sound_data, id_name=p)"
      ],
      "metadata": {
        "id": "kHEWRjv4sHl6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Audio Control D-scale\n",
        "\n",
        "- pitches D, E, F♯, G, A, B, and C♯"
      ],
      "metadata": {
        "id": "KOTYk5JHhPWI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#\n",
        "f = 'Data-Augmentation-with-Python/pluto_data/control-d-major.mp3'\n",
        "data_amp, sam_rate, fname = pluto._fetch_audio_data(f)\n",
        "pluto.audio_control_dmajor = [data_amp, sam_rate, fname, f]\n",
        "pluto._draw_audio(data_amp, sam_rate, 'Original: ' + fname)\n",
        "# display audio\n",
        "display(IPython.display.Audio(data_amp, rate=sam_rate))"
      ],
      "metadata": {
        "id": "mg-sQtNhsHrs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Time shift"
      ],
      "metadata": {
        "id": "PukgLsehH7RK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %CARRY-OVER\n",
        "\n",
        "!pip install audiomentations\n",
        "#\n",
        "# tested with version 0.29.0\n",
        "# !pip install audiomentations==0.29.0"
      ],
      "metadata": {
        "id": "KTxX760Qr9rT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "import audiomentations\n",
        "#\n",
        "@add_method(PacktDataAug)\n",
        "def _fetch_1_sample(self, df, dsize=1):\n",
        "\n",
        "  \"\"\"\n",
        "  Fetch a sample from the given DataFrame.\n",
        "\n",
        "  Parameters:\n",
        "  - df (pd.DataFrame): The input DataFrame from which a sample is to be fetched.\n",
        "  - dsize (int, optional): The size of the sample to fetch. Default is 1.\n",
        "\n",
        "  Returns:\n",
        "  - str: The 'fname' value from the sampled row.\n",
        "\n",
        "  Note:\n",
        "  This function assumes that the DataFrame 'df' has a column named 'fname'.\n",
        "  \"\"\"\n",
        "  p = df.sample(dsize)\n",
        "  p.reset_index(drop=True, inplace=True)\n",
        "  return p.fname[0]\n",
        "#\n",
        "@add_method(PacktDataAug)\n",
        "def _audio_transform(self, df, xtransform, title=''):\n",
        "\n",
        "  \"\"\"\n",
        "  Apply audio transformation and display the result.\n",
        "\n",
        "  Args:\n",
        "    df: (pandas DataFrame), with column 'fname' that contains the file name of each audio file.\n",
        "    xtransform: (audiomentations.core.BaseTransformer), audio transformation to apply.\n",
        "    title: (string), title of the plot. Default value is empty string.\n",
        "\n",
        "  Returns: None.\n",
        "  \"\"\"\n",
        "  if (type(df) is list):\n",
        "    data_amp, sam_rate, fname, lname = self.audio_control_dmajor\n",
        "  else:\n",
        "    lname = self._fetch_1_sample(df)\n",
        "    data_amp, sam_rate, fname = self._fetch_audio_data(lname)\n",
        "  #\n",
        "  xaug = xtransform(data_amp, sample_rate=sam_rate)\n",
        "  # augmented\n",
        "  self._draw_audio(xaug, sam_rate, title + ' Augmented: ' + fname)\n",
        "  display(IPython.display.Audio(xaug, rate=sam_rate))\n",
        "  # original\n",
        "  self._draw_audio(data_amp, sam_rate, 'Original: ' + fname)\n",
        "  display(IPython.display.Audio(data_amp, rate=sam_rate))\n",
        "  return"
      ],
      "metadata": {
        "id": "6WFJJUPJB9mu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "@add_method(PacktDataAug)\n",
        "def play_aug_time_shift(self, df,\n",
        "  min_fraction=-0.2,\n",
        "  max_fraction=0.8,\n",
        "  rollover=True,\n",
        "  title='Time Shift',\n",
        "  id_name=None):\n",
        "\n",
        "  \"\"\"\n",
        "  Play audio samples with time shift augmentation.\n",
        "\n",
        "  Args:\n",
        "    df: (pandas DataFrame), with column 'fname' that contains the file name of each audio file.\n",
        "    min_fraction: (float), minimum fraction of the audio to shift. Default value is -0.2.\n",
        "    max_fraction: (float), maximum fraction of the audio to shift. Default value is 0.8.\n",
        "    rollover: (bool), If True, the audio is shifted so that the beginning of the audio is played\n",
        "      at the end and vice versa. Default value is True.\n",
        "    title: (string), title of the plot. Default value is empty string.\n",
        "    id_name: (string), the column name that contains the unique identifier of the audio file. If `None`,\n",
        "      the 'fname' column is used. Default value is None.\n",
        "\n",
        "  Returns: None.\n",
        "  \"\"\"\n",
        "\n",
        "  xtransform = audiomentations.Shift(\n",
        "    min_fraction = min_fraction,\n",
        "    max_fraction = max_fraction,\n",
        "    rollover = rollover,\n",
        "    p=1.0\n",
        "  )\n",
        "  self._audio_transform(df, xtransform, title=title)\n",
        "  return"
      ],
      "metadata": {
        "id": "V5FLws7qC6NO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_time_shift(pluto.df_music_data, min_fraction=0.5)"
      ],
      "metadata": {
        "id": "pgH4RMspMitm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_time_shift(pluto.df_voice_data, min_fraction=0.5)"
      ],
      "metadata": {
        "id": "zC2H1WnCMiw1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_time_shift(pluto.df_sound_data, min_fraction=0.5)"
      ],
      "metadata": {
        "id": "yQfIr19EMizv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_time_shift(pluto.audio_control_dmajor, min_fraction=0.2)"
      ],
      "metadata": {
        "id": "u15bwOFWMi3f"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Time stretch"
      ],
      "metadata": {
        "id": "1EWF8w9DxGP9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "@add_method(PacktDataAug)\n",
        "def play_aug_time_stretch(self, df, min_rate=0.2,max_rate=6.8,leave_length_unchanged=True,title='Time Stretch'):\n",
        "\n",
        "  \"\"\"\n",
        "  Play audio samples with time stretch augmentation.\n",
        "\n",
        "  Args:\n",
        "    df: (pandas DataFrame), with column 'fname' that contains the file name of each audio file.\n",
        "    min_rate: (float), minimum rate to use for time stretching. Default value is 0.2.\n",
        "    max_rate: (float), maximum rate to use for time stretching. Default value is 6.8.\n",
        "    leave_length_unchanged: (bool), If True, the length of the audio is preserved by changing the\n",
        "      sample rate. Default value is True.\n",
        "    title: (string), title of the plot. Default value is \"Time Stretch\".\n",
        "\n",
        "  Returns: None.\n",
        "  \"\"\"\n",
        "\n",
        "  xtransform = audiomentations.TimeStretch(\n",
        "    min_rate = min_rate,\n",
        "    max_rate = max_rate,\n",
        "    leave_length_unchanged = leave_length_unchanged,\n",
        "    p=1.0\n",
        "  )\n",
        "  self._audio_transform(df, xtransform, title=title)\n",
        "  return\n",
        "  # librosa.effects.time_stretch under the hood"
      ],
      "metadata": {
        "id": "AvtnmRBJMi7e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_time_stretch(pluto.audio_control_dmajor, max_rate=5.4)"
      ],
      "metadata": {
        "id": "-5SWv7o2hvmM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_time_stretch(pluto.df_music_data, max_rate=3.0)"
      ],
      "metadata": {
        "id": "bw7E0ohgx2E0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_time_stretch(pluto.df_voice_data, max_rate=3.5)"
      ],
      "metadata": {
        "id": "S0MZ_zi_x2Il"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_time_stretch(pluto.df_sound_data, max_rate=2.5)"
      ],
      "metadata": {
        "id": "_84BezWZx2Mn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# pluto.fname_id"
      ],
      "metadata": {
        "id": "H3Is8metx2R8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Pitch scaling"
      ],
      "metadata": {
        "id": "VY71UYRI4H3-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "@add_method(PacktDataAug)\n",
        "def play_aug_pitch_scaling(self, df, min_semitones=-6.0,max_semitones=6.0,title='Pitch Scaling'):\n",
        "\n",
        "  \"\"\"\n",
        "  Play audio samples with pitch scaling augmentation.\n",
        "\n",
        "  Args:\n",
        "    df: (pandas DataFrame), with column 'fname' that contains the file name of each audio file.\n",
        "    min_semitones: (float), minimum number of semitones to pitch shift. Default value is -6.0.\n",
        "    max_semitones: (float), maximum number of semitones to pitch shift. Default value is 6.0.\n",
        "    title: (string), title of the plot. Default value is \"Pitch Scaling\".\n",
        "\n",
        "  Returns: None.\n",
        "  \"\"\"\n",
        "\n",
        "  xtransform = audiomentations.PitchShift(\n",
        "    min_semitones = min_semitones,\n",
        "    max_semitones = max_semitones,\n",
        "    p=1.0)\n",
        "  self._audio_transform(df, xtransform, title=title)\n",
        "  return"
      ],
      "metadata": {
        "id": "2TMvLcLv4N0T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_pitch_scaling(pluto.audio_control_dmajor,min_semitones=-6.0,max_semitones=6.0)"
      ],
      "metadata": {
        "id": "nR-8pnQT4N34"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# pluto.fname_id"
      ],
      "metadata": {
        "id": "jMfcBNPS4N6p"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_pitch_scaling(pluto.df_music_data,min_semitones=-11.0, max_semitones=-9.0)"
      ],
      "metadata": {
        "id": "VnKRiTYe4N-2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_pitch_scaling(pluto.df_voice_data,min_semitones=-6.0, max_semitones=6.0)"
      ],
      "metadata": {
        "id": "-5M0Wmiy4OEG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_pitch_scaling(pluto.df_sound_data,min_semitones=4.0, max_semitones=11.0)"
      ],
      "metadata": {
        "id": "6Xr7R0Sr7kVh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Noise injection, add Gaussian noise"
      ],
      "metadata": {
        "id": "rcNZA9Kl9tMY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "@add_method(PacktDataAug)\n",
        "def play_aug_noise_injection(self, df, min_amplitude=0.002,max_amplitude=0.2,title='Gaussian noise injection'):\n",
        "\n",
        "  \"\"\"\n",
        "  Play audio samples with noise injection (Gaussian noise) augmentation.\n",
        "\n",
        "  Args:\n",
        "    df: (pandas DataFrame), with column 'fname' that contains the file name of each audio file.\n",
        "    min_amplitude: (float), minimum amplitude of the noise to add. Default value is 0.002.\n",
        "    max_amplitude: (float), maximum amplitude of the noise to add. Default value is 0.2.\n",
        "    title: (string), title of the plot. Default value is \"Gaussian noise injection\".\n",
        "\n",
        "  Returns: None.\n",
        "  \"\"\"\n",
        "\n",
        "  xtransform = audiomentations.AddGaussianNoise(\n",
        "    min_amplitude = min_amplitude,\n",
        "    max_amplitude = max_amplitude,\n",
        "    p=1.0)\n",
        "  self._audio_transform(df, xtransform, title=title)\n",
        "  return"
      ],
      "metadata": {
        "id": "cgPOfP4g9tfg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_noise_injection(pluto.audio_control_dmajor, min_amplitude=0.02,max_amplitude=0.05)"
      ],
      "metadata": {
        "id": "cV7Fi5Rd9tir"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# pluto.fname_id"
      ],
      "metadata": {
        "id": "_vfUBvnm9tlv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_noise_injection(pluto.df_music_data, max_amplitude=0.01)"
      ],
      "metadata": {
        "id": "lF1OdXFv9tph"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_noise_injection(pluto.df_voice_data, max_amplitude=0.01)"
      ],
      "metadata": {
        "id": "XkLvL-KY7kbD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_noise_injection(pluto.df_sound_data, max_amplitude=0.022)"
      ],
      "metadata": {
        "id": "Onk3dHLXDfn3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Polarity Inversion"
      ],
      "metadata": {
        "id": "5JSmgvZnF4n5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "@add_method(PacktDataAug)\n",
        "def play_aug_polar_inverse(self, df, title='Polarity inversion'):\n",
        "\n",
        "  \"\"\"\n",
        "  Play audio samples with polarity inversion augmentation.\n",
        "\n",
        "  Args:\n",
        "    df: (pandas DataFrame), with column 'fname' that contains the file name of each audio file.\n",
        "    title: (string), title of the plot. Default value is \"Polarity inversion\".\n",
        "\n",
        "  Returns: None.\n",
        "  \"\"\"\n",
        "\n",
        "  xtransform = audiomentations.PolarityInversion(\n",
        "    p=1.0)\n",
        "  self._audio_transform(df, xtransform, title=title)\n",
        "  return"
      ],
      "metadata": {
        "id": "cu83SaDoF40t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_polar_inverse(pluto.audio_control_dmajor)"
      ],
      "metadata": {
        "id": "etIYC71qF47G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_polar_inverse(pluto.df_voice_data)"
      ],
      "metadata": {
        "id": "j_5G88ynDfr1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Low pass Filter"
      ],
      "metadata": {
        "id": "XuNqAvhhJmiG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "@add_method(PacktDataAug)\n",
        "def play_aug_low_pass_filter(self, df,\n",
        "  min_cutoff_freq=150, max_cutoff_freq=7500,\n",
        "  min_rolloff=12, max_rolloff=24,\n",
        "  title='Low pass filter'):\n",
        "\n",
        "  \"\"\"\n",
        "  Play audio samples with low pass filter augmentation.\n",
        "\n",
        "  Args:\n",
        "    df: (pandas DataFrame), with column 'fname' that contains the file name of each audio file.\n",
        "    min_cutoff_freq: (float), minimum cutoff frequency in Hz. Default value is 150.\n",
        "    max_cutoff_freq: (float), maximum cutoff frequency in Hz. Default value is 7500.\n",
        "    min_rolloff: (float), minimum rolloff in dB/octave. Default value is 12.\n",
        "    max_rolloff: (float), maximum rolloff in dB/octave. Default value is 24.\n",
        "    title: (string), title of the plot. Default value is \"Low pass filter\".\n",
        "\n",
        "  Returns: None.\n",
        "  \"\"\"\n",
        "\n",
        "  xtransform = audiomentations.LowPassFilter(\n",
        "    min_cutoff_freq = min_cutoff_freq,\n",
        "    max_cutoff_freq = max_cutoff_freq,\n",
        "    min_rolloff = min_rolloff,\n",
        "    max_rolloff = max_rolloff,\n",
        "    p=1.0)\n",
        "  self._audio_transform(df, xtransform, title=title)\n",
        "  return"
      ],
      "metadata": {
        "id": "4TY1ALSIJpwH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_low_pass_filter(pluto.audio_control_dmajor)"
      ],
      "metadata": {
        "id": "wxdSfke3Jpza"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_low_pass_filter(pluto.df_music_data)"
      ],
      "metadata": {
        "id": "lmSI3FeCJp95"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_low_pass_filter(pluto.df_voice_data)"
      ],
      "metadata": {
        "id": "6vt_YXOwJqFE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_low_pass_filter(pluto.df_sound_data)"
      ],
      "metadata": {
        "id": "eBySWhVaDfyX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#High pass filter"
      ],
      "metadata": {
        "id": "ac8gYYuaPtXJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "@add_method(PacktDataAug)\n",
        "def play_aug_high_pass_filter(self, df,\n",
        "  min_cutoff_freq=20, max_cutoff_freq=2400,\n",
        "  min_rolloff=12, max_rolloff=24,\n",
        "  title='High pass filter'):\n",
        "\n",
        "  \"\"\"\n",
        "  Play audio samples with high pass filter augmentation.\n",
        "\n",
        "  Args:\n",
        "    df: (pandas DataFrame), with column 'fname' that contains the file name of each audio file.\n",
        "    min_cutoff_freq: (float), minimum cutoff frequency in Hz. Default value is 20.\n",
        "    max_cutoff_freq: (float), maximum cutoff frequency in Hz. Default value is 2400.\n",
        "    min_rolloff: (float), minimum rolloff in dB/octave. Default value is 12.\n",
        "    max_rolloff: (float), maximum rolloff in dB/octave. Default value is 24.\n",
        "    title: (string), title of the plot. Default value is \"High pass filter\".\n",
        "\n",
        "  Returns: None.\n",
        "  \"\"\"\n",
        "\n",
        "  xtransform = audiomentations.HighPassFilter(\n",
        "    min_cutoff_freq = min_cutoff_freq,\n",
        "    max_cutoff_freq = max_cutoff_freq,\n",
        "    min_rolloff = min_rolloff,\n",
        "    max_rolloff = max_rolloff,\n",
        "    p=1.0)\n",
        "  self._audio_transform(df, xtransform, title=title)\n",
        "  return"
      ],
      "metadata": {
        "id": "m5KvMy9aOvci"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_high_pass_filter(pluto.audio_control_dmajor)"
      ],
      "metadata": {
        "id": "0pSH7NkEOvft"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_high_pass_filter(pluto.df_music_data)"
      ],
      "metadata": {
        "id": "9W9vfnPrOvmE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_high_pass_filter(pluto.df_voice_data)"
      ],
      "metadata": {
        "id": "jlV3urETSAEh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_high_pass_filter(pluto.df_sound_data)"
      ],
      "metadata": {
        "id": "Wzo4Tg3QSALp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Band pass filter"
      ],
      "metadata": {
        "id": "vPARs4o0R9cW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# %%writefile -a {pluto_chapter_7}\n",
        "\n",
        "@add_method(PacktDataAug)\n",
        "def play_aug_band_pass_filter(self, df,\n",
        "  min_center_freq=200, max_center_freq=4000,\n",
        "  min_bandwidth_fraction=0.5,max_bandwidth_fraction=1.99,\n",
        "  min_rolloff=12, max_rolloff=24,\n",
        "  title='Band pass filter'):\n",
        "\n",
        "  \"\"\"\n",
        "  Play audio samples with band pass filter augmentation.\n",
        "\n",
        "  Args:\n",
        "    df: (pandas DataFrame), with column 'fname' that contains the file name of each audio file.\n",
        "    min_center_freq: (float), minimum center frequency in Hz. Default value is 200.\n",
        "    max_center_freq: (float), maximum center frequency in Hz. Default value is 4000.\n",
        "    min_bandwidth_fraction: (float), minimum bandwidth fraction. Default value is 0.5.\n",
        "    max_bandwidth_fraction: (float), maximum bandwidth fraction. Default value is 1.99.\n",
        "    min_rolloff: (float), minimum rolloff in dB/octave. Default value is 12.\n",
        "    max_rolloff: (float), maximum rolloff in dB/octave. Default value is 24.\n",
        "    title: (string), title of the plot. Default value is \"Band pass filter\".\n",
        "\n",
        "  Returns: None.\n",
        "  \"\"\"\n",
        "\n",
        "  xtransform = audiomentations.BandPassFilter(\n",
        "    min_center_freq = min_center_freq,\n",
        "    max_center_freq = max_center_freq,\n",
        "    min_bandwidth_fraction = min_bandwidth_fraction,\n",
        "    max_bandwidth_fraction = max_bandwidth_fraction,\n",
        "    min_rolloff = min_rolloff,\n",
        "    max_rolloff = max_rolloff,\n",
        "    p=1.0)\n",
        "  self._audio_transform(df, xtransform, title=title)\n",
        "  return"
      ],
      "metadata": {
        "id": "L2izp4R1R9qq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_band_pass_filter(pluto.audio_control_dmajor)"
      ],
      "metadata": {
        "id": "AJvzrDMBR9uQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_band_pass_filter(pluto.df_music_data)"
      ],
      "metadata": {
        "id": "hSh4Ni1BR90-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_band_pass_filter(pluto.df_voice_data)"
      ],
      "metadata": {
        "id": "LD9ruyJAR97N"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.play_aug_band_pass_filter(pluto.df_sound_data)"
      ],
      "metadata": {
        "id": "Vdm9EjhIR9-Q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Sneak peek (Optional)"
      ],
      "metadata": {
        "id": "DdR2XCt2iYXT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.text_marry_lamb = 'Mary had a little lamb, whose fleece was white as snow. And everywhere that Mary went, the lamb was sure to go.'"
      ],
      "metadata": {
        "id": "bdU2Iu38gKfp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "x = numpy.array([ord(c) for c in pluto.text_marry_lamb])"
      ],
      "metadata": {
        "id": "81uDBwK2iXN5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "k = pandas.DataFrame(x, columns=['tdata'])\n",
        "k.head()"
      ],
      "metadata": {
        "id": "CTTp4kdDjkk-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "pluto.fname_id=0"
      ],
      "metadata": {
        "id": "hyy5IlqVa28x"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "canvas, pic = matplotlib.pyplot.subplots(1, 1, figsize=(11, 4))\n",
        "# pics = pic.flatten()\n",
        "pluto._draw_area_with_neg(x,pic,izero=64)\n",
        "pic.set_title('Text time-series graph: Marry had a little lamb...', fontsize=18.)\n",
        "pic.set_xlabel('Character, letters are in blue, punctuations are in yellow', fontsize=16.)\n",
        "pic.set_ylabel('ASCII value')\n",
        "pic.grid()\n",
        "#\n",
        "# display and save image\n",
        "canvas.tight_layout()\n",
        "pluto._drop_image(canvas)\n",
        "canvas.show()"
      ],
      "metadata": {
        "id": "3-9UVyIMjkoF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print('End of chapter 7')"
      ],
      "metadata": {
        "id": "TQ2YW9Ib1rBC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Push up all changes (Optional)"
      ],
      "metadata": {
        "id": "LEj7fgaIN9_S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "- username: duchaba\n",
        "\n",
        "- password: [use the token]"
      ],
      "metadata": {
        "id": "lHXRf21BT9N8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# import os\n",
        "# f = 'Data-Augmentation-with-Python'\n",
        "# os.chdir(f)\n",
        "# !git add -A\n",
        "# !git config --global user.email \"duc.haba@gmail.com\"\n",
        "# !git config --global user.name \"duchaba\"\n",
        "# !git commit -m \"end of session\"\n",
        "# # do the git push in the xterm console\n",
        "# #!git push"
      ],
      "metadata": {
        "id": "eSXJKJFlOEeE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# import google.colab\n",
        "# import datetime\n",
        "# @add_method(PacktDataAug)\n",
        "# def zip_download(self,dname='/content/Data-Augmentation-with-Python/pluto_img'):\n",
        "#   d = datetime.datetime.now()\n",
        "#   d = d.strftime('%Y%m%d_')\n",
        "#   fname = f'img{d}{self.fname_id}.zip'\n",
        "#   !zip {fname} {dname}/*\n",
        "#   google.colab.files.download(fname)\n",
        "#   return\n",
        "# #"
      ],
      "metadata": {
        "id": "JMJgBjC1Px5A"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# pluto.zip_download()"
      ],
      "metadata": {
        "id": "BOX3HWSOaiKe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EzO7lDYDWeLz"
      },
      "source": [
        "# Summary"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X2iUPf3EWePd"
      },
      "source": [
        "Every chaper will begin with same base class \"PacktDataAug\".\n",
        "\n",
        "✋ FAIR WARNING:\n",
        "\n",
        "- The coding uses long and complete function path name.\n",
        "\n",
        "- Pluto wrote the code for easy to understand and not for compactness, fast execution, nor cleaverness.\n",
        "\n",
        "- Use Xterm to debug cloud server\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# !pip install colab-xterm\n",
        "# %load_ext colabxterm\n",
        "# %xterm"
      ],
      "metadata": {
        "id": "vXRG3KaeWbGx"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "nlpaug_dev",
      "language": "python",
      "name": "nlpaug_dev"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.5"
    },
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "include_colab_link": true
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}