WMCTF_Music_game2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /usr/local/lib/python3.6/dist-packages/tensorflow/python/ops/resource_variable_ops.py:1666: 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"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras import models\n",
    "import librosa, librosa.display\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import tensorflow as tf\n",
    "tf.compat.v1.disable_eager_execution()\n",
    "\n",
    "# Load pre-trained image recognition model\n",
    "model = models.load_model('model.h5')\n",
    "\n",
    "# Grab a reference to the first and last layer of the neural net\n",
    "model_input_layer = model.layers[0].input\n",
    "model_output_layer = model.layers[-1].output\n",
    "\n",
    "# Choose an ImageNet object to fake\n",
    "object_type_to_fake = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def invlogamplitude(S):\n",
    "    \"\"\"librosa.logamplitude is actually 10_log10, so invert that.\"\"\"\n",
    "    return 10.0**(S/10.0)\n",
    "\n",
    "def get_wav(path):\n",
    "    y, sr = librosa.load(path,sr=None)\n",
    "    return (y,sr)\n",
    "\n",
    "def get_mfcc(y,sr):\n",
    "    data=librosa.feature.mfcc(y,sr=sr)\n",
    "    data=np.array(data)\n",
    "\n",
    "    '''to unified format'''\n",
    "    while len(data[0])>30:\n",
    "        data=np.delete(data,-1,axis=1)\n",
    "        data=np.delete(data,0,axis=1)\n",
    "    while len(data[0])<30:\n",
    "        data=np.insert(data,-1,values=data.T[-1],axis=1)\n",
    "    return data.T\n",
    "\n",
    "def get_wav_mfcc(path):\n",
    "    y,sr=get_wav(path)\n",
    "    data=get_mfcc(y,sr)\n",
    "    return data\n",
    "\n",
    "def checkdifferent(mfcc):\n",
    "    mfcc1=get_wav_mfcc('example.wav')\n",
    "    return np.mean(np.abs(mfcc1-mfcc))\n",
    "    '''\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    '''\n",
    "\n",
    "def get_mfcc_wav(mfcc):\n",
    "    sr=16000\n",
    "    mfccs=mfcc.reshape(30,20).T\n",
    "    # Build reconstruction mappings,\n",
    "    n_mfcc = mfccs.shape[0]\n",
    "    n_mel = 128\n",
    "    dctm = librosa.filters.dct(n_mfcc, n_mel)\n",
    "    n_fft = 2048\n",
    "    mel_basis = librosa.filters.mel(sr, n_fft)\n",
    "    \n",
    "    # Empirical scaling of channels to get ~flat amplitude mapping.\n",
    "    bin_scaling = 1.0/np.maximum(0.0005, np.sum(np.dot(mel_basis.T, mel_basis),axis=0))\n",
    "    \n",
    "    # Reconstruct the approximate STFT squared-magnitude from the MFCCs.\n",
    "    recon_stft = bin_scaling[:, np.newaxis] * np.dot(mel_basis.T,invlogamplitude(np.dot(dctm.T, mfccs)))\n",
    "    \n",
    "    # Impose reconstructed magnitude on white noise STFT.\n",
    "    excitation = np.random.randn(15000)\n",
    "    E = librosa.stft(excitation)\n",
    "    recon = librosa.istft(E/np.abs(E)*np.sqrt(recon_stft))\n",
    "    return recon"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "waveData=get_wav_mfcc('example.wav')\n",
    "original_mfcc=waveData"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a copy of the input to hack on\n",
    "hacked_mfcc = np.copy(original_mfcc).reshape(1,30,20)\n",
    "\n",
    "# How much to update the hacked image in each iteration\n",
    "learning_rate = 1000\n",
    "\n",
    "# Define the cost function.\n",
    "# Our 'cost' will be the likelihood out image is the target class according to the pre-trained model\n",
    "cost_function = model_output_layer[0, object_type_to_fake]\n",
    "\n",
    "# We'll ask Keras to calculate the gradient based on the input image and the currently predicted class\n",
    "# In this case, referring to \"model_input_layer\" will give us back image we are hacking.\n",
    "gradient_function = K.gradients(cost_function, model_input_layer)[0]\n",
    "\n",
    "# Create a Keras function that we can call to calculate the current cost and gradient\n",
    "grab_cost_and_gradients_from_model = K.function([model_input_layer, K.learning_phase()], [cost_function, gradient_function])\n",
    "\n",
    "cost = 0.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cost:5.208832%,rate1000,diff:3.0\n",
      "cost:22.427215%,rate1000,diff:3.1\n",
      "cost:98.332489%,rate1000,diff:3.4\n",
      "cost:98.902833%,rate1000,diff:3.5\n"
     ]
    }
   ],
   "source": [
    "flag=0\n",
    "while True:\n",
    "    test_mfcc=get_mfcc(get_mfcc_wav(hacked_mfcc),16000).reshape(1,30,20)\n",
    "    cost, gradients = grab_cost_and_gradients_from_model(test_mfcc)\n",
    "    diff=checkdifferent(test_mfcc.reshape(30,20))\n",
    "    print(\"cost:{:.8}%,rate{},diff:{:.2}\".format(cost * 100,learning_rate,diff))    \n",
    "    if cost>0.95 and diff<4:\n",
    "        flag+=1\n",
    "    if cost > 0.95 and flag>1:\n",
    "        break\n",
    "    #if cost > 0.7:\n",
    "    #    learning_rate/=10\n",
    "    if cost<0.7:\n",
    "        flag=0\n",
    "    \n",
    "    newhacked_mfcc = hacked_mfcc+(gradients * learning_rate)\n",
    "    if checkdifferent(get_mfcc(get_mfcc_wav(newhacked_mfcc),16000))>=4:\n",
    "        print(\"change\")\n",
    "        learning_rate/=2\n",
    "    else:\n",
    "        hacked_mfcc=newhacked_mfcc\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "while True:\n",
    "    recon=get_mfcc_wav(hacked_mfcc)\n",
    "    librosa.output.write_wav('yours.wav', recon, 16000)\n",
    "    print('1')\n",
    "    if checkdifferent(get_wav_mfcc('yours.wav'))<4:\n",
    "        break\n",
    "plt.style.use('seaborn-darkgrid')\n",
    "plt.figure(1)\n",
    "plt.subplot(211)\n",
    "ou,s=get_wav('example.wav')\n",
    "librosa.display.waveplot(ou, 16000)\n",
    "plt.subplot(212)\n",
    "librosa.display.waveplot(recon,16000)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}