{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# Importing libraries","metadata":{}},{"cell_type":"code","source":"import pandas as pd\nimport numpy as np\nimport os\nimport matplotlib.pyplot as plt\nimport librosa\nimport librosa.display\nimport IPython.display as ipd\nfrom tqdm import tqdm","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"pd.set_option('display.max_colwidth',200)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_dir='../data/train/audio'\nSAMPLE_RATE=16000\nN_FFT = 512\nHOP_LENGTH=128","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Loading train data","metadata":{}},{"cell_type":"code","source":"def load_train_data(path):\n    tmp_list=[]\n    for (dirpath, dirnames, filenames) in os.walk(path):\n        for file in filenames:\n            if file.endswith('.wav'):\n                tmp_path=os.path.join(dirpath, file)\n                class_label = tmp_path.split('/')[-2]\n                data,_ = librosa.load(tmp_path,sr=SAMPLE_RATE)\n                tmp_list.append([tmp_path,class_label,data])\n            else:\n                continue\n    return  pd.DataFrame(tmp_list,columns=['file_path','class_label','data'])","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df = load_train_data(train_dir)\ntrain_df","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Preprocessing train data","metadata":{}},{"cell_type":"markdown","source":"## separating noisy recordings from the rest\n**noisy records** - records in folder **\"_background_noise_\"**","metadata":{}},{"cell_type":"code","source":"noise_records_index = train_df.loc[train_df.class_label=='_background_noise_'].index\nnoise_df = train_df.iloc[noise_records_index].reset_index(drop=True)\ntrain_df = train_df.drop(noise_records_index).reset_index(drop=True)\ndel noise_records_index","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* increasing selection","metadata":{}},{"cell_type":"code","source":"validation_labels =  'yes, no, up, down, left, right, on, off, stop, go'.split(', ')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"tmp = [col for col in train_df.class_label.unique() if col not in validation_labels]\nprint(tmp)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# train_df.loc[~train_df.class_label.isin(validation_labels),'class_label'].count()/len(tmp)\nnot_val_records_increas_selec = pd.DataFrame(columns=['file_path','class_label','data'])\nfor label in tmp:\n    selected_label_records = train_df.loc[train_df.class_label == label]\n    resempled = selected_label_records.sample(n=2350,replace=True,axis=0)\n    not_val_records_increas_selec = pd.concat([not_val_records_increas_selec,resempled], ignore_index=True)\n    del selected_label_records, resempled\nnot_val_records_increas_selec","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Changing class labels","metadata":{}},{"cell_type":"code","source":"# unknown records indexes\n# unknown_record_index = [indx for indx in train_df.index if train_df.loc[indx,'class_label'] not in validation_labels]\n# unknown_record_index = train_df.loc[train_df.class_label.isin(validation_labels)].index","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df = train_df.drop(train_df.loc[~train_df.class_label.isin(validation_labels)].index).reset_index(drop=True)\ntrain_df.class_label.value_counts()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* Merge increased non validation records and validation records","metadata":{}},{"cell_type":"code","source":"train_df = pd.concat([train_df,not_val_records_increas_selec], ignore_index=True)\ndisplay(train_df.head(3))\ndisplay(train_df.class_label.value_counts())","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df.loc[train_df.loc[~train_df.class_label.isin(validation_labels)].index,'class_label'] = 'unknown'\ndisplay(train_df.class_label.value_counts())","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Making silence records\ngenerating new records from records in  **\"_background_noise_\"** folder","metadata":{}},{"cell_type":"code","source":"def make_silence_records(noise_df):\n    silence_df = pd.DataFrame(columns=['file_path','class_label','data'])\n    for indx in noise_df.index:\n        record = noise_df.loc[indx,'data']\n        record_length = len(record)\n        duration = int(record_length/SAMPLE_RATE)\n        zeros = np.zeros(SAMPLE_RATE)\n        for i in range(duration*7):\n            random_sample = np.random.choice(record,SAMPLE_RATE)\n            silence_df = silence_df.append(\n                pd.Series([noise_df.loc[indx,'file_path'],'silence',  random_sample],\n                          index=['file_path','class_label','data']),\n                ignore_index=True,)  \n            silence_df = silence_df.append(\n                pd.Series(['own_made_silence','silence',\n                           zeros],\n                          index=['file_path','class_label','data']),\n                ignore_index=True,)\n#         silence_df = silence_df.sample(frac=1).reset_index(drop=True)\n    return silence_df","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"silence_df = make_silence_records(noise_df)\nsilence_df.tail()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Making all records of the same length\n* Due to some records have a duration less than 1s. I should to pad them to the same length of 1s.","metadata":{}},{"cell_type":"code","source":"def pad_records_length(df):\n    smaller=0\n    bigger =0\n    df = df.copy()\n    SAMPLES_PER_TRACK= 16000\n    for indx in df.index:\n        record = df.loc[indx,'data']\n        if len(record)<SAMPLES_PER_TRACK:\n            smaller+=1\n            tmp = np.zeros(SAMPLES_PER_TRACK)\n            tmp[:record.shape[0]]=record\n            df.loc[indx,'data']= tmp\n            del tmp\n        elif len(record)>SAMPLES_PER_TRACK:\n            bigger+=1\n            df.loc[indx,'data']= record[:SAMPLES_PER_TRACK]   \n    print(f'Record {bigger} - bigger than 1s\\nRecords smaller then 1s = {smaller}')\n    return df","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df = pad_records_length(train_df)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Data Augmentation","metadata":{}},{"cell_type":"markdown","source":"* center records","metadata":{}},{"cell_type":"code","source":"def center_records(data,sr=16000):\n    df = data.copy()\n    df['centered'] = None\n    half = sr//2\n    for indx in tqdm(df.index):\n        data = df.loc[indx,'data']\n        center = np.argmax(data)\n        if center<half:\n            shift = int(half-center)\n            centered_data = np.roll(data, shift)\n        elif center>half:\n            shift = int(half-center)\n            centered_data = np.roll(data, shift)\n        df.at[indx,'centered'] = centered_data\n    return df","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df=center_records(train_df)\ntrain_df.head(2)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Finding records that do not match their class","metadata":{}},{"cell_type":"code","source":"def is_bad_audio(df,column_name = 'data'):\n    df = df.copy()\n    df['is_bad'] = None\n    for indx in df.index:\n        data = df.loc[indx,column_name]\n        features=librosa.feature.spectral_centroid(y=data,sr=16000,n_fft=512,hop_length=128)[0]\n        m = np.mean(features)\n        t = np.std(features)\n        if  t < 80:\n            # silent\n            df.loc[indx,'is_bad']='silent'\n        elif (m > 2550 and t < 300):\n            # noisy\n            df.loc[indx,'is_bad']='noise'\n        elif (m > 3500 and t > 1200):\n            # distorted\n            df.loc[indx,'is_bad']='distorted'\n        else:\n            df.loc[indx,'is_bad']='good'\n    return df","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df = is_bad_audio(train_df)\ndisplay(train_df.head(1))\ndisplay(train_df.is_bad.value_counts())","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Working with not matched records","metadata":{}},{"cell_type":"code","source":"#  changing noise records to silent class all distorted to unknown and dropping silent \ndistorted_indx = train_df.loc[train_df.is_bad=='distorted'].index\nnoise_indx = train_df.loc[train_df.is_bad=='noise'].index\nsilent_indx = train_df.loc[train_df.is_bad=='silent'].index","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df.loc[[*distorted_indx,*silent_indx],'class_label'] = 'unknown'\ntrain_df.loc[noise_indx,'class_label'] = 'silence'\n# train_df = train_df.drop(silent_indx).reset_index(drop=True)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df.class_label.value_counts()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# selected manually\nsilent = \"../data/train/audio/stop/1fd85ee4_nohash_0.wav\"\n\nwrong_words = ['../data/train/audio/right/46a153d8_nohash_4.wav',\n               '../data/train/audio/down/c9b653a0_nohash_1.wav',\n               '../data/train/audio/dog/94de6a6a_nohash_0.wav']\n\nbad_records = ['../data/train/audio/on/99b05bcf_nohash_0.wav',\n               '../data/train/audio/up/a13e0a74_nohash_0.wav',\n               '../data/train/audio/no/e5dadd24_nohash_0.wav']","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"train_df.loc[train_df.file_path.isin([*wrong_words,*bad_records]),'class_label'] = 'unknown'\ntrain_df.loc[train_df.file_path=='silent','class_label'] = 'silence'","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Merge silence dataframe and train dataframe","metadata":{}},{"cell_type":"code","source":"merged_df = pd.concat([train_df,silence_df], ignore_index=True)\nmerged_df.head(2)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* Silence records wasn't centered that's why there are have not in centered column and thats should be changed because in future i'll use it.","metadata":{}},{"cell_type":"code","source":"# change records  with none values in centered column to data column values\ncentered_nan_index = merged_df.loc[merged_df.centered.isna()==True].index\nmerged_df.loc[centered_nan_index,'centered'] = merged_df.loc[centered_nan_index,'data']\nmerged_df.tail()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Create features","metadata":{}},{"cell_type":"markdown","source":"* Mel Spectrograms","metadata":{}},{"cell_type":"code","source":"def create_mel_spec_features(data,column_name = 'data'):\n    df = data.copy()\n    df['mel_spec'] = None\n    for indx in tqdm(df.index):\n        mel_spec = librosa.feature.melspectrogram(df.loc[indx,column_name],sr=16000,n_fft=512,hop_length=128,n_mels=90)\n        log_mel_spec = librosa.power_to_db(mel_spec)\n        df.loc[indx,'mel_spec'] = [log_mel_spec]\n    return df","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"merged_df_with_mel =create_mel_spec_features(merged_df)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Train validation test split","metadata":{}},{"cell_type":"code","source":"from sklearn.model_selection import train_test_split\ntrain,test = train_test_split(merged_df_with_mel, test_size=0.3,random_state=21)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Defining feature and target variables","metadata":{}},{"cell_type":"markdown","source":"* Train","metadata":{}},{"cell_type":"code","source":"from sklearn.preprocessing import LabelEncoder\nfrom keras.utils import to_categorical\nencoder = LabelEncoder()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = np.array([rec for rec in train['mel_spec']])","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_train = train.class_label.values\ny_train = encoder.fit_transform(y_train)\n\nclasses_encoded = encoder.classes_\nnum_classes = len(classes_encoded)\nprint(num_classes)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"y_train = to_categorical(y_train,num_classes = num_classes)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* Test","metadata":{}},{"cell_type":"code","source":"X_test = np.array([rec for rec in test['mel_spec']])\ny_test = test.class_label.values\ny_test = encoder.transform(y_test)\ny_test = to_categorical(y_test,num_classes = num_classes)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* Reshapping features data","metadata":{}},{"cell_type":"code","source":"# Reshape for mel spec features\nX_train = np.reshape(X_train,(X_train.shape[0],X_train.shape[1],X_train.shape[2],1))\nX_test = np.reshape(X_test,(X_test.shape[0],X_test.shape[1],X_test.shape[2],1))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Building model","metadata":{}},{"cell_type":"code","source":"from keras.models import Sequential\nfrom keras.layers import Dense, Conv2D,AveragePooling2D, MaxPooling2D,Flatten,Dropout,BatchNormalization\nfrom keras.callbacks import EarlyStopping, ModelCheckpoint","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model = Sequential()\nmodel.add(Conv2D(8, 2, padding='valid',activation='relu', input_shape=X_train.shape[1:]))\nfor i in range(2):\n    model.add(MaxPooling2D((2,2)))\n    model.add(BatchNormalization())\n    model.add(Conv2D(8, 2, activation='relu'))\nmodel.add(Dropout(0.2))\nmodel.add(Conv2D(16, 3, activation='relu'))\nmodel.add(AveragePooling2D((2, 2)))\nmodel.add(BatchNormalization())\nmodel.add(Dropout(0.2))\nmodel.add(Flatten())\nmodel.add(Dense(32, activation='relu'))\nmodel.add(Dense(num_classes, activation='softmax'))\nmodel.summary()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=3)\nmc = ModelCheckpoint('best_model.h5', monitor='val_loss', mode='min', verbose=1, save_best_only=True)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"model.fit(X_train,y_train, batch_size=64, epochs=25, validation_data=(X_val,y_val),callbacks=[es, mc]) ","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* Loading best saved model","metadata":{}},{"cell_type":"code","source":"from keras.models import load_model\nsaved_model = load_model('best_model.h5')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Evaluate the model on the test data using `evaluate`\nprint(\"Evaluate on test data\")\nresults = saved_model.evaluate(X_test, y_test, batch_size=128)\nprint(\"test loss, test acc:\", results)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* Making test prediction","metadata":{}},{"cell_type":"code","source":"prediction = saved_model.predict(X_test)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* Confusion matrix","metadata":{}},{"cell_type":"code","source":"from sklearn.metrics import confusion_matrix\nfrom sklearn.metrics import classification_report","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"pred = [classes_encoded[np.argmax(p)] for p in prediction]\ntrue_val = [classes_encoded[np.argmax(p)] for p in y_test]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"print(classification_report(true_val, pred, target_names=classes_encoded))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from my_module import plot_confusion_matrix\nplot_confusion_matrix(confusion_matrix(true_val, pred),classes_encoded,normalize=False)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Submition predition","metadata":{}},{"cell_type":"markdown","source":"* Load submission data","metadata":{}},{"cell_type":"code","source":"test_dir = '../data/test'\ndef load_test_data(path):    \n    tmp_list=[]\n    for (dirpath, dirnames, filenames) in os.walk(path):\n        for file in filenames:\n            if file.endswith('.wav'):\n                tmp_path=os.path.join(dirpath, file)\n                data,_ = librosa.load(tmp_path,sr=SAMPLE_RATE)\n                tmp_list.append([file,data])\n            else:\n                continue\n    return  pd.DataFrame(tmp_list,columns=['file_path','data'])","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_data = load_test_data(test_dir)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* preprocess","metadata":{}},{"cell_type":"code","source":"test_data = pad_records_length(test_data)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_data = center_records(test_data)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"test_data = create_mel_spec_features(test_data, column_name='centered')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_sub = np.array([rec for rec in test_data.mel_spec])\nX_sub = np.reshape(X_sub,(X_sub.shape[0],X_sub.shape[1],X_sub.shape[2],1))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"prediction_for_sub = saved_model.predict(X_sub)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"fname = test_data.file_path.values","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"classes_encoded = 'down go left no off on right silence stop unknown up yes'.split()\nsub_prediction =[classes_encoded[np.argmax(p)] for p in prediction_for_sub]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"* make pandas dataframe and save to csv file","metadata":{}},{"cell_type":"code","source":"submission_df = pd.DataFrame(list(zip(fname,sub_prediction)),columns=['fname','label'])\nsubmission_df.to_csv('submission.csv',index=False)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"![%D0%A1%D0%BD%D0%B8%D0%BC%D0%BE%D0%BA%20%D1%8D%D0%BA%D1%80%D0%B0%D0%BD%D0%B0%202021-10-11%20%D0%B2%2010.40.49.png](attachment:%D0%A1%D0%BD%D0%B8%D0%BC%D0%BE%D0%BA%20%D1%8D%D0%BA%D1%80%D0%B0%D0%BD%D0%B0%202021-10-11%20%D0%B2%2010.40.49.png)","metadata":{},"attachments":{"%D0%A1%D0%BD%D0%B8%D0%BC%D0%BE%D0%BA%20%D1%8D%D0%BA%D1%80%D0%B0%D0%BD%D0%B0%202021-10-11%20%D0%B2%2010.40.49.png":{"image/png":"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"}}}]}