{"cells":[{"metadata":{"_cell_guid":"f5be4ac1-d0a2-442b-ac57-f7b0c764dae9","_uuid":"876f0b63cba53419fbf7527034bf2c5f93885309"},"cell_type":"markdown","source":"# <center>Freesound General-Purpose Audio Tagging Challenge</center>  \n<center>Freesound通用音频标注挑战  </center>  \n\n\n![Logo](https://upload.wikimedia.org/wikipedia/commons/3/3c/Freesound_project_website_logo.png)\n\nFreesound is a collaborative database of Creative Commons Licensed sounds. The aim of this competition is to classify audio files that cover real-world sounds from musical instruments, humans, animals, machines, etc. Few of the labels are: `Trumpet`, `Squeak`, `Meow`, `Applause` and `Finger_sapping`.  One of the challenges is that not all labels are manually verified. A creative solution should be able to partially rely on these *weak* annotations.  \nFreesound是Creative Commons Licensed声音的协作数据库。 本次比赛的目的是对音频文件进行分类，这些文件涵盖乐器，人类，动物，机器等真实世界的声音。很少量的标签是：小号，吱吱声，喵喵声，掌声和打响指。其中一个挑战是并非所有标签都经过了人工验证。创造性的解决方案应该能够部分依赖这些弱注释。  \n\nLet's take a tour of the data visualization and model building through this kernel. If you like this work, please show your support by upvotes. Happy Kaggling!  \n让我们通过这个内核浏览数据可视化和模型构建。 如果您喜欢这项工作，请通过upvotes表示您的支持。 快乐的Kaggling！  \n翻译注释：七月在线fan  \n\n\n### Contents\n1. [Exploratory Data Analysis](#eda)探索性数据分析\n    * [Loading data](#loading_data)加载数据\n    * [Distribution of Categories](#distribution)类的分布\n    * [Reading Audio Files](#audio_files)浏览音频文件\n    * [Audio Length](#audio_length)音频长度\n2. [Building a Model using Raw Wave](#1d_model_building)使用原始波建立模型\n    * [Model Discription](#1d_discription)模型描述\n    * [Configuration](#configuration)结构\n    * [DataGenerator class](#data_generator)数据生成器\n    * [Normalization](#1d_normalization)1d归一化\n    * [Training 1D Conv](#1d_training) 训练1维卷积神经网络\n    * [Ensembling 1D Conv Predictions](#1d_ensembling)集成一维卷积的预测结果\n3. [Introduction to MFCC](#intro_mfcc)MFCC简介\n    * [Generating MFCC using Librosa](#librosa_mfcc)使用Librosa生成MFCC\n4. [Building a Model using MFCC](#2d_model_building)使用MFCC构建模型\n    * [Preparing Data](#2d_data)准备数据\n    * [Normalization](#2d_normalization)归一化\n    * [Training 2D Conv on MFCC](#2d_training)训练MFCC的2D Conv\n    * [Ensembling 2D Conv Predictions](#2d_ensembling)集成2D Conv的预测结果\n5. [Ensembling 1D Conv and 2D Conv Predictions](#1d_2d_ensembling)集成1D Conv和2D Conv的预测结果\n6. [Results and Conclusion](#conclusion)结果和结论  \n\n参考：  \nhttps://www.jianshu.com/p/880bd818fca0  \nhttps://www.kaggle.com/fizzbuzz/beginner-s-guide-to-audio-data  \n\n\n<a id=\"eda\"></a>\n## <center>1. Exploratory Data Analysis探索性数据分析</center>"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:36:54.711167Z","start_time":"2019-03-04T09:36:54.703389Z"},"_cell_guid":"39ab28e6-67b2-4129-9dbb-846c81ba85f2","_uuid":"d00095bca1801c4058b75e706058a0651808596f","trusted":true},"cell_type":"code","source":"# Change this to True to replicate the result\nCOMPLETE_RUN = False\n#True代表运行全部数据集，False代表运行部分数据集","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"d4905db9-005f-42f0-aa6b-1408acef7371","_uuid":"4c065a37dd33e869d93ccd8d78daed628e58112b"},"cell_type":"markdown","source":"<a id=\"loading_data\"></a>\n### Loading data  \n加载数据"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:00.484785Z","start_time":"2019-03-04T09:36:54.718390Z"},"_cell_guid":"5abea3ac-4fa5-4c4f-893f-7f2afa49e523","_kg_hide-output":false,"_uuid":"337e0950ca948be32d5d881c1a3c675ccf7ac523","trusted":true},"cell_type":"code","source":"import numpy as np#矩阵运算\nnp.random.seed(1001)#随机种子\n\nimport os#系统命令\nimport shutil#文件操作\n\nimport IPython#交互式编程\nimport matplotlib#绘图\nimport matplotlib.pyplot as plt\nimport pandas as pd#特征工程\nimport seaborn as sns#绘图\nfrom tqdm import tqdm_notebook#进度条\nfrom sklearn.model_selection import StratifiedKFold#分层采样交叉切分\n\n%matplotlib inline\n#将图内嵌到notebook\nmatplotlib.style.use('ggplot')#样式美化","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:00.658108Z","start_time":"2019-03-04T09:37:00.551676Z"},"_cell_guid":"97700e3e-82e1-4ce2-9da4-3f8f264e7558","_kg_hide-output":false,"_uuid":"2ca1929548de57afb1c4fde19c10f7b18c64264e","trusted":true},"cell_type":"code","source":"train = pd.read_csv(\"../input/freesound-audio-tagging/train.csv\")#pandas 读csv:读训练集\ntest = pd.read_csv(\"../input/freesound-audio-tagging/sample_submission.csv\")#pandas 读csv:读提交样本","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:00.715990Z","start_time":"2019-03-04T09:37:00.661770Z"},"_cell_guid":"a418ce4d-b104-4710-b50d-e9ab1e7e420f","_kg_hide-output":false,"_uuid":"1acc16aa65e8f39a5abd8b60906740a671659f1b","trusted":true},"cell_type":"code","source":"train.head()#pandas head:读前面几行\n#描述了每个wav文件对应的ID，以及它的分类，还有该分类标注是否经过人工审查，如下：","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:00.733180Z","start_time":"2019-03-04T09:37:00.719522Z"},"_cell_guid":"afceb447-9a8f-4cc4-a7b2-eabc75c3f0aa","_kg_hide-output":false,"_uuid":"dad27c6a5ef1fdad658ce710fe16fca58c75a05c","scrolled":true,"trusted":true},"cell_type":"code","source":"print(\"Number of training examples=\", train.shape[0], \"  Number of classes=\", len(train.label.unique()))\n#train.shape[0]有多少行\n#len(train.label.unique())有多少个独一无二的类","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:00.754754Z","start_time":"2019-03-04T09:37:00.739800Z"},"_cell_guid":"99b8ebbd-aa18-427a-ab33-e88553a564f6","_kg_hide-output":false,"_uuid":"0c3e7629b5e60cfad2a7e1681dcf6e7c55c92e43","trusted":true},"cell_type":"code","source":"print(train.label.unique())#打印出独一无二的类名","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"008c5a97-9c50-4a52-9b65-568986f9bbd6","_uuid":"2edb326e66f4c699bd3cc5ec43279d40e7777180"},"cell_type":"markdown","source":"<a id=\"distribution\"></a>\n### Distribution of Categories  \n不同类的分布"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:02.153458Z","start_time":"2019-03-04T09:37:00.762360Z"},"_cell_guid":"67e5b2e9-cee7-4bf0-84d4-b79bfa6928fd","_uuid":"fef9ca7602b65d3637884eddd38fa5f01a530e81","scrolled":false,"trusted":true},"cell_type":"code","source":"category_group = train.groupby(['label', 'manually_verified']).count()\n#pandas groupby : 根据标签和是否人工验证将训练集分组，然后计算每个分组的数量\n\nplot = category_group.unstack().   reindex(category_group.unstack().sum(axis=1).sort_values().index)\\\n          .plot(kind='bar', stacked=True, title=\"Number of Audio Samples per Category\", figsize=(16,10))\n#pandas unstack : 默认将category_group.index.names[-1] (即manually_verified)作为列名，对series不堆积成pandas\n#pandas sum(axis=1) : 对列聚合求和(即变为1列)\n#pandas sort_values : 排序，默认升序\n#pandas index : 得到索引列表\n#pandas reindex : 重建索引。\n#category_group.unstack().reindex(category_group.unstack().sum(axis=1).sort_values().index)：含义如下\n#将category_group不堆积，然后根据每个类别的数目做升序排序\n#\\是换行符\n#pandas plot : 画柱状图bar， stacked是将两列堆成一列 , title标题 ， figsize图像大小\n\nplot.set_xlabel(\"Category\")#x轴标签\nplot.set_ylabel(\"Number of Samples\");#y轴标签","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:02.171253Z","start_time":"2019-03-04T09:37:02.156556Z"},"_cell_guid":"29538dc2-387a-4910-a203-f105c97ce0e6","_kg_hide-output":true,"_uuid":"c2ca61efa1696baa87f831f7df927fd1cba7abbf","trusted":true},"cell_type":"code","source":"print('Minimum samples per category = ', min(train.label.value_counts()))\n# min(train.label.value_counts()) ： train的label列中每个类的数目的最小值\nprint('Maximum samples per category = ', max(train.label.value_counts()))\n# max(train.label.value_counts()) ： train的label列中每个类的数目的最大值","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"a715d812-98fc-459a-8695-13940b2ca1de","_uuid":"d0ed18e06d39f962d1a2a58f4743171c9c4970e9"},"cell_type":"markdown","source":"We observe that:  \n我们观察到：  \n1. The number of audio samples per category is **non-nform**. The minimum number of audio samples in a category is `94` while the maximum is `300`  \n每个类别的音频样本数量是非空的。 一个类别中音频样本的最小数量为94，而最大值为300  \n\n2. Also, the proportion of `maually_verified` labels per category is non-uniform.\n<a id=\"audio_files\"></a>  \n此外，每个类别的maually_verified(人工标记)标签的比例是不均匀的(通过柱状图可以看出来)。  \n\n\n### Reading Audio Files  \n阅读音频文件  \n\nThe audios are [Pulse-code modulated](https://en.wikipedia.org/wiki/Audio_bit_depth) with a [bit depth](https://en.wikipedia.org/wiki/Audio_bit_depth) of 16 and a [sampling rate](https://en.wikipedia.org/wiki/Sampling_%28signal_processing%29) of 44.1 kHz  \n音频采用脉冲编码调制，比特长度为16位，采样率为44.1 kHz  \n\n\n![16-bit PCM](https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/Pcm.svg/500px-Pcm.svg.png)\n\n* **Bit-depth = 16**: The amplitude of each sample in the audio is one of 2^16 (=65536) possible values.   \n比特长度= 16 ， 意思是 ： 音频中每个取样的幅度是2 ^ 16（= 65536）个可能值之一。  \n* **Samplig rate = 44.1 kHz**: Each second in the audio consists of 44100 samples. So, if the duration of the audio file is 3.2 seconds, the audio will consist of 44100\\*3.2 = 141120 values.  \nSamplig rate = 44.1 kHz  意思是：音频中每秒包含44100次取样。 因此，如果音频文件的持续时间为3.2秒，则音频将包含44100 * 3.2 = 141120个值。  \n\nLet's listen to an audio file in our dataset and load it to a numpy array  \n让我们收听数据集中的音频文件并将其加载到numpy数组中  "},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:02.268257Z","start_time":"2019-03-04T09:37:02.175308Z"},"_cell_guid":"20d2c517-01f9-46a9-b339-6ce415bc59d2","_uuid":"e15d81dcb2a4433b94182eb588ccb183e27fa700","trusted":true},"cell_type":"code","source":"import IPython.display as ipd  # To play sound in the notebook 展示\nfname = '/kaggle/input/freesound-audio-tagging/audio_train/audio_train/' + '00044347.wav'   # Hi-hat 鼓\nipd.Audio(fname)#播放音频","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:02.312636Z","start_time":"2019-03-04T09:37:02.280849Z"},"_cell_guid":"efe10cb8-13f1-405e-8b71-ca5758ee18d4","_uuid":"101f9997c5c8cd0392c1f367684331d3f6e80422","trusted":true},"cell_type":"code","source":"# Using wave library\nimport wave#解析wav文件\nwav = wave.open(fname)#打开wav文件\nprint(\"Sampling (frame) rate = \", wav.getframerate())#帧率\nprint(\"Total samples (frames) = \", wav.getnframes())#总帧数\nprint(\"Duration = \", wav.getnframes()/wav.getframerate())#时间","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:02.414332Z","start_time":"2019-03-04T09:37:02.317632Z"},"_cell_guid":"3c9f1564-fa50-4f4b-87d9-2070fc44770d","_uuid":"e4ea69354f032c0b511b50693c750e19fb4f6cb3","trusted":true},"cell_type":"code","source":"# Using scipy科学计算\nfrom scipy.io import wavfile#读取wav文件\nrate, data = wavfile.read(fname)#读取wav文件，返回采样率(帧率)和numpy形式的数据\nprint(\"Sampling (frame) rate = \", rate)\nprint(\"Total samples (frames) = \", data.shape)#数据维度\nprint(data)#打印数据","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"3c6c2a6f-4914-4e13-84be-6b8492487c7b","_uuid":"bacb576c223074c03d0cb5c55b917df2e1261498"},"cell_type":"markdown","source":"Let's plot the audio frames"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:03.208550Z","start_time":"2019-03-04T09:37:02.417833Z"},"_cell_guid":"eeb3e8ab-106f-4e67-84fd-7bf8c9847c8e","_uuid":"a1e25d48f74b38784d7588e5c33af9b03248e7d3","scrolled":false,"trusted":true},"cell_type":"code","source":"plt.plot(data, '-', );\n#matplotlib绘图。鼓声从大到小","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"79293dfd-e254-47f3-8909-ff32f08f87aa","_uuid":"762301b9c5d7653d761205e172ff3da88745400f"},"cell_type":"markdown","source":"Let's zoom in on first 1000 frames"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:37:03.480128Z","start_time":"2019-03-04T09:37:03.214382Z"},"_cell_guid":"bfb06a3e-b501-4570-89ea-008781414144","_uuid":"7c1b21e52e83d0bc723a48a32ced87445a540fa9","trusted":true},"cell_type":"code","source":"plt.figure(figsize=(16, 4))#画布大小\nplt.plot(data[:500], '.'); #matplotlib plot . :前500个数据的散点图\nplt.plot(data[:500], '-');#matplotlib plot - :前500个数据的折线图","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"42761f3d-0d20-4a97-843a-02186299f76b","_uuid":"b3a730fc5ee4a9ab5904cddda84a05ac118c749d"},"cell_type":"markdown","source":"<a id=\"audio_length\"></a>\n### Audio Length  \n音频的长度  \n\nWe shall now analyze the lengths of the audio files in our dataset  \n我们现在将分析数据集中音频文件的长度"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:38:22.773136Z","start_time":"2019-03-04T09:37:03.483442Z"},"_cell_guid":"40b7ba05-45df-4779-be29-b177b9b9b8e1","_uuid":"867f0074922314b78de6bd9d14b308b634d1fbbe","scrolled":false,"trusted":true},"cell_type":"code","source":"train['nframes'] = train['fname'].apply(lambda f: wave.open('/kaggle/input/freesound-audio-tagging/audio_train/audio_train/' + f).getnframes())\n#pandas apply ： 对训练集的fname列下每个元素做一个运算： lambda匿名函数，将每个元素所对应的wav文件打开，返回每个音频的总帧数。\ntest['nframes'] = test['fname'].apply(lambda f: wave.open('/kaggle/input/freesound-audio-tagging/audio_test/audio_test/' + f).getnframes())\n#pandas apply ： 对测试集的fname列下每个元素做一个运算： lambda匿名函数，将每个元素所对应的wav文件打开，返回每个音频的总帧数。\n\n_, ax = plt.subplots(figsize=(16, 4))\n#创建子图的公共布局\nsns.violinplot(ax=ax, x=\"label\", y=\"nframes\", data=train)\n#seaborn violinplot 提琴图\nplt.xticks(rotation=90)\n#matplotlib xticks : x轴刻度旋转90度\nplt.title('Distribution of audio frames, per label', fontsize=16)\n#matplotlib title ： 画出标题\nplt.show()\n#展示","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"fa8fa2bd-359c-4f53-b94b-67a6c1acde64","_uuid":"92ea60bb1827c9ec4dd261d015739dde762f9b18"},"cell_type":"markdown","source":"We observe:  \n我们观察到：  \n\n1. The distribution of audio length across labels is non-uniform and has high variance.  \n不同标签的音频的长度的分布是不均匀的，并且具有高的方差。  \nLet's now analyze the frame length distribution in Train and Test.  \n现在让我们分析一下Train和Test中的帧长分布。"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-05T06:57:00.633523Z","start_time":"2019-03-05T06:56:58.779665Z"},"_cell_guid":"e49045f1-7c44-4f1a-b740-d45ec3b6b321","_uuid":"0ec5676601b04e3fdbae4052122c9db1a68251a9","trusted":true},"cell_type":"code","source":"fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(16,5))  \n#matpoltlib subplots :创建一系列的子图  nrows子图行的个数，ncols子图列的个数 ,figsize画布尺寸, axes子图的轴， fig图\ntrain.nframes.hist(bins=100, ax=axes[0])\n#pandas hist ： 训练集的总帧数的直方图，bins是分桶数， ax是画在某个子图的轴上0代表第一个子图的轴\ntest.nframes.hist(bins=100, ax=axes[1])\n#pandas hist ： 测试集的总帧数的直方图，bins是分桶数， ax是画在某个子图的轴上1代表第二个子图的轴\nplt.suptitle('Frame Length Distribution in Train and Test', ha='center', fontsize='large');\n#标题","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"72c8dc2d-8385-4f74-8820-8d805fee8dc0","_uuid":"3e517330a7209f25fa69056db1214f27fb585824"},"cell_type":"markdown","source":"We observe:  \n我们观察到：  \n1. Majority of the audio files are short.\n大多数音频文件很短。  \n1. There are four `abnormal` length in the test histogram. Let's analyze them.  \n测试直方图(右图)中有四个异常长度。 我们来分析一下吧。  "},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:38:24.362140Z","start_time":"2019-03-04T09:38:24.224948Z"},"_cell_guid":"f36e006f-fb47-4134-94a8-aede32f770ad","_uuid":"8495f1f7fdaffa09623458aa66803c6a2e156537","scrolled":true,"trusted":true},"cell_type":"code","source":"abnormal_length = [707364, 353682, 138474, 184338]\n\nfor length in abnormal_length:\n    abnormal_fnames = test.loc[test.nframes == length, 'fname'].values\n    #DataFrame.values : 只返回DataFrame中的值，不返回轴的标签\n    #test.nframes == length ： pandas boolean index\n    #pandas loc ： 定位， 获取异常长度的音频的文件名\n    \n    print(\"Frame length = \", length, \" Number of files = \", abnormal_fnames.shape[0], end=\"   \")\n    #异常长度  有这个异常长度的文件数量  \n    \n    fname = np.random.choice(abnormal_fnames)\n    #np random choice : 随机取样一次\n    \n    print(\"Playing \", fname)\n    #打印出这个随机样本的名字\n    IPython.display.display(ipd.Audio( '../input/freesound-audio-tagging/audio_test/audio_test/' + fname))\n    #展示这个随机音频样本","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"146baca0-66cc-4ce1-8d16-16ae5764a354","_uuid":"64462b38a986a2f40deeb6a053b9d99d8f6993b5"},"cell_type":"markdown","source":"<a id=\"1d_model_building\"></a>  \n## <center>2. Building a Model using Raw Wave使用原始波建立模型  </center>\nWe will build two models:  \n我们将建立两个模型：  \n1. The first model will take the raw audio (1D array) as input and the primary operation will be Conv1D  \n第一个模型将原始音频（1D阵列）作为输入，主要操作将是Conv1D  \n\n2. The second model will take the MFCCs as input. (We will explain MFCC later)  \n第二个模型将MFCC作为输入。 （我们稍后会在第四节解释MFCC） \n\n\n<a id=\"1d_discription\"></a>\n### Keras Model using raw wave  \n使用原始波的Keras模型  \n\nOur model has the architecture as follows:  \n我们的模型具有如下架构：\n![raw](https://raw.githubusercontent.com/zaffnet/images/master/images/raw_model.jpg)\n\n**Important重要提示：**  \nDue to the time limit on Kaggle Kernels, it is not possible to perform 10-fold training of a large model. I have trained the model locally and uploaded its output files as a dataset. If you wish to train the bigger model, change `COMPLETE_RUN = True` at the beginning of the kernel.  \n由于Kaggle Kernels的时间限制，无法对大型模型进行10次训练。 我已在本地训练模型并将模型上传为数据集。 如果您希望训练更大的模型，请在内核开头更改COMPLETE_RUN = True。"},{"metadata":{"_cell_guid":"0ef1062c-be8a-4021-a50a-3df9bacd30fc","_uuid":"2df0e6e509896eaefd30f6b4c15b55736760aafa","collapsed":true},"cell_type":"markdown","source":"#### Some sssential imports  \n导入必要的库"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:38:34.844551Z","start_time":"2019-03-04T09:38:24.367121Z"},"_cell_guid":"58fbb75c-1ef8-478f-a5fd-3fe6cfda32af","_kg_hide-output":true,"_uuid":"36454f818dcbe02852e7a639d428a004a387ce9f","trusted":true},"cell_type":"code","source":"import librosa#音频处理库\nimport numpy as np#矩阵运算\nimport scipy#科学计算\nfrom keras import losses, models, optimizers\n#keras Model:泛型模型，即广义的拥有输入和输出的模型\n#keras losses:损失函数\n#keras optimizers: 优化器\nfrom keras.activations import relu, softmax\n#keras relu softmax:激活函数\n\nfrom keras.callbacks import (EarlyStopping, LearningRateScheduler,\n                             ModelCheckpoint, TensorBoard, ReduceLROnPlateau)\n#回调函数，在训练时使用，查看模型状态和统计。\n#EarlyStopping当评价指标不再提升时，减少学习率\n#LearningRateScheduler学习速率定时器\n#ModelCheckpoint模型检查点\n#TensorBoard可视化工具\n#ReduceLROnPlateau当标准评估停止提升时，降低学习速率。\n\nfrom keras.layers import (Convolution1D, Dense, Dropout, GlobalAveragePooling1D, \n                          GlobalMaxPool1D, Input, MaxPool1D, concatenate)\n#keras layers: keras的神经网络层\n#keras Convolution1D:一维卷积层（即时域卷积）\n#keras Dense：全连接层，Dropout随机失活层\n#keras Dropout:随机失活层\n#keras GlobalAveragePooling1D:为时域信号施加全局平均值池化\n#keras Input:输入层\n#keras MaxPool1D:为时域信号施加最大池化\n#keras concatenate:融合层\n\nfrom keras.utils import Sequence, to_categorical\n#keras Sequence :序列数据的基类，例如一个数据集\n#keras to_categorical：将类别向量(从0到nb_classes的整数向量)映射为二进制类别矩阵","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"64df4fea-4917-4762-b9be-68163f590c13","_uuid":"927b4d615e24291f3c9510b653e723dc031fd042"},"cell_type":"markdown","source":"![](http://)<a id=\"configuration\"></a>\n#### Configuration配置"},{"metadata":{"_cell_guid":"1dda9e10-5b51-430a-b20d-a319695df25d","_uuid":"a9dc3968c8915e1d96f0bc011e67db26932ab0a3"},"cell_type":"markdown","source":"The Configuration object stores those learning parameters that are shared between data generators, models, and training functions. Anything that is `global` as far as the training is concerned can become the part of Configuration object.  \nConfiguration对象存储了 在数据生成器，模型和训练函数之间共享的学习参数。 就训练而言，任何“全局”的东西都可以成为Configuration对象的一部分。"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:38:34.862774Z","start_time":"2019-03-04T09:38:34.852416Z"},"_cell_guid":"e0836104-1a4d-485d-9cc1-3e5b82f449de","_uuid":"66640745984135b853d36eac127fb2da302319ad","trusted":true},"cell_type":"code","source":"# 配置类\nclass Config(object):\n    def __init__(self,\n                 sampling_rate=16000, audio_duration=2, n_classes=41,\n                 use_mfcc=False, n_folds=10, learning_rate=0.0001, \n                 max_epochs=50, n_mfcc=20):\n        #音频的频率\n        self.sampling_rate = sampling_rate\n        #音频的时长\n        self.audio_duration = audio_duration\n        #音频的类别数目\n        self.n_classes = n_classes\n        #是否使用mfcc模型\n        self.use_mfcc = use_mfcc\n        \n        self.n_mfcc = n_mfcc\n        #折数\n        self.n_folds = n_folds\n        #学习速率\n        self.learning_rate = learning_rate\n        #轮数\n        self.max_epochs = max_epochs\n\n        #音频长度\n        self.audio_length = self.sampling_rate * self.audio_duration\n\n        #self.dim维度\n        if self.use_mfcc:\n            #MFCC不是一个采样点就计算一次，需要/512\n            self.dim = (self.n_mfcc, 1 + int(np.floor(self.audio_length/512)), 1)\n        else:\n            self.dim = (self.audio_length, 1)","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"dbdcf3fb-f915-482c-ad8f-d8578de8f080","_uuid":"b1a794352ac7505abcf212d1b1c6deef32178ab3","collapsed":true},"cell_type":"markdown","source":"<a id=\"data_generator\"></a>\n#### DataGenerator Class  \n数据生成类"},{"metadata":{"_cell_guid":"059d4658-f1a4-4d6a-ae67-05140fc9bac6","_uuid":"f1a0716a545ade83970005951719e71cebe35ab2"},"cell_type":"markdown","source":"The DataGenerator class inherits from **`keras.utils.Sequence`** . It is useful for preprocessing and feeding the data to a Keras model.   \nDataGenerator类继承自keras.utils.Sequence。 它对于预处理和将数据喂到Keras模型非常有用。  \n\n* Once initialized with a batch_size, it computes the number of batches in an epoch. The **`__len__`** method tells Keras how many batches to draw in each epoch.   \n一旦使用batch_size初始化，它就会计算一轮中的批次数。 __len__方法告诉Keras每轮有多少批次。  \n* The **`__getitem__`** method takes an index (which is the batch number) and returns a batch of the data (both X and y) after calculating the offset. During test time, only `X` is returned.  \n__getitem__方法获取索引（这是批号）并在计算偏移量后返回一批数据（X和y）。 在测试期间，仅返回X.  \n* If we want to perform some action after each epoch (like shuffle the data, or increase the proportion of augmented data), we can use the **`on_epoch_end`** method.  \n如果我们想在每轮之后执行一些操作（比如打乱数据，或者增加 增强数据的比例），我们可以使用on_epoch_end方法。  \n\nNote:\n**`Sequence`** are a safer way to do multiprocessing. This structure guarantees that the network will only train once on each sample per epoch which is not the case with generators.  \n注意：Sequence是进行多进程处理的更安全的方法。这种结构保证网络在每个时期每个样本只训练一次，这与生成器不同"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:38:34.891018Z","start_time":"2019-03-04T09:38:34.869697Z"},"_cell_guid":"f9d14e7d-89d8-42f0-9eb3-f895645b2de2","_uuid":"aca30bc0f6fccf71e4b9a68e5c04c1aaf950b169","trusted":true},"cell_type":"code","source":"# 在使用keras训练model的时候，一般会将所有的训练数据加载到内存中，然后喂给网络，但当内存有限，且数据量过大时，此方法则不再可用。\n# 因此我们准备构建一个数据迭代器。\n\nclass DataGenerator(Sequence):\n    #keras Sequence :序列数据的基类，例如一个数据集\n    \n    def __init__(self, config, data_dir, list_IDs, labels=None, \n                 batch_size=64, preprocessing_fn=lambda x: x):\n        self.config = config\n        #数据地址\n        self.data_dir = data_dir\n        #文件名\n        self.list_IDs = list_IDs\n        #类别标签\n        self.labels = labels\n        #批次大小\n        self.batch_size = batch_size\n        #预处理函数，默认不处理\n        self.preprocessing_fn = preprocessing_fn\n        #在每轮结束后调用\n        self.on_epoch_end()\n        #维度\n        self.dim = self.config.dim\n\n    # 以下两个函数是必须在Sequence类里实现的方法\n    # 返回一共有多少个batch\n    def __len__(self):\n        #计算数据/批次=轮数\n        return int(np.ceil(len(self.list_IDs) / self.batch_size))\n        #np.ceil向上取整\n        \n    # 返回第index个batch内的内容\n    def __getitem__(self, index):\n        # 返回某个批次在全部数据中索引的起止\n        indexes = self.indexes[index*self.batch_size:(index+1)*self.batch_size]\n        # 返回某个批次的文件名列表\n        list_IDs_temp = [self.list_IDs[k] for k in indexes]\n        return self.__data_generation(list_IDs_temp)\n\n    def on_epoch_end(self):\n        #在每轮结束后，将list_IDs文件名列表与[0,1,2,3,,,]列表对应\n        self.indexes = np.arange(len(self.list_IDs))\n        #numpy arange : 在给定间隔内返回均匀间隔的值\n\n    def __data_generation(self, list_IDs_temp):\n        #批次数据的长度\n        cur_batch_size = len(list_IDs_temp)\n        \n        X = np.empty((cur_batch_size, *self.dim))\n        #x是模型的输入\n        #numpy empty : 创建空数组\n        # 这里的*是因为self.dim类似shape，是一个多维的参数，通过*(解包)当成参数列表传递进去\n\n        input_length = self.config.audio_length\n        #输入长度\n        \n        for i, ID in enumerate(list_IDs_temp):\n            #i是序号，ID是内容\n            file_path = self.data_dir + ID\n            #file_path是音频文件的路径\n            \n            data, _ = librosa.core.load(file_path, sr=self.config.sampling_rate,\n                                        res_type='kaiser_fast')\n            #librosa.core.load : 读取音频文件并取样\n            #返回值data是np.ndarray形式的音频序列数据，sr是采样频率，res_type是快速类型。\n\n            # Random offset / Padding\n            #如果音频长度大于模型的输入长度    过长 从中取出指定长度的音频 \n            if len(data) > input_length:\n                max_offset = len(data) - input_length\n                # 数据长度比模型输入长度长多少\n                offset = np.random.randint(max_offset)\n                #在(0,max_offset)之间随机生成一个整数\n                data = data[offset:(input_length+offset)]\n                #随机截取一段长度为input_length的音频\n            else:\n                # 如果音频过短，补成指定长度\n                if input_length > len(data):\n                    max_offset = input_length - len(data)\n                    # 模型输入长度比数据长度长多少\n                    offset = np.random.randint(max_offset)\n                    #在(0,max_offset)之间随机生成一个整数\n                else:\n                    offset = 0\n                    #如果相等，偏移量为0\n                data = np.pad(data, (offset, input_length - len(data) - offset), \"constant\")\n                #nimpy pad : 在数组前后填充常数。数组原本长度是len(data)，在前面随机填充offset个常数，在后面随机填充input_length - len(data) - offset个常数，总长度变为input_length\n                \n            # Normalization + Other Preprocessing\n            #如果使用mfcc模型\n            #梅尔频率倒谱系数  https://www.cnblogs.com/BaroC/p/4283380.html\n            if self.config.use_mfcc:\n                data = librosa.feature.mfcc(data, sr=self.config.sampling_rate,\n                                                   n_mfcc=self.config.n_mfcc)\n                #以numpy_ndarray的形式，返回梅尔频率倒谱系数\n                data = np.expand_dims(data, axis=-1)\n                #在数组最后添加一个维度\n            else:\n                # 这里的preprocessing_fn是预处理函数，对音频进行归一化处理，代码在后面\n                data = self.preprocessing_fn(data)[:, np.newaxis]\n                # [:, np.newaxis] ： 增添一个新维度以符合网络Input形状\n            X[i,] = data\n            #x是模型的输入\n            # 第i个X 为 第i个处理之后的data.\n            \n        # 如果带有label(说明是训练集)\n        if self.labels is not None:\n            y = np.empty(cur_batch_size, dtype=int)\n            #y是每个批次的标签\n            for i, ID in enumerate(list_IDs_temp):\n                y[i] = self.labels[ID]\n            return X, to_categorical(y, num_classes=self.config.n_classes)\n        #如果不带label(说明是测试集)\n        else:\n            return X","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"49a23330-291d-4eb7-aeb9-4abcfd648277","_uuid":"6b69d10980c7aad004c6a7fa860c649d0b875a0f"},"cell_type":"markdown","source":"<a id=\"1d_normalization\"></a>\n#### Normalization  \n归一化  \nNormalization is a crucial preprocessing step. The simplest method is rescaling the range of features to scale the range in [0, 1].   \n归一化是一个至关重要的预处理步骤。 最简单的方法是线性调整特征范围以缩放到[0,1]中的范围。"},{"metadata":{},"cell_type":"markdown","source":"线性函数归一化（摘自百面机器学习）  \n![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:38:34.901065Z","start_time":"2019-03-04T09:38:34.894686Z"},"_cell_guid":"bb5936dd-5fb1-4894-8165-6daf372a6832","_uuid":"c9db10ad526815730a6e5a1f057de8c9bff12615","trusted":true},"cell_type":"code","source":"#公式如上\ndef audio_norm(data):\n    max_data = np.max(data)\n    min_data = np.min(data)\n    data = (data-min_data)/(max_data-min_data+1e-6)\n    #+1e-6是防止分母为0\n    return data-0.5","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"3b9656b0-31d3-47ea-9bb3-789a40026793","_uuid":"c2f0bbd810926b309d3b02473e937a2a86bc9005"},"cell_type":"markdown","source":"* The dummy model is just for debugging purpose.  \n假设模型仅用于调试目的。  \n* Our 1D Conv model is fairly deep and is trained using Adam Optimizer with a learning rate of 0.0001  \n我们的一维Conv模型非常深，使用Adam Optimizer进行训练，学习率为0.0001"},{"metadata":{},"cell_type":"markdown","source":"![raw](https://raw.githubusercontent.com/zaffnet/images/master/images/raw_model.jpg)"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:38:34.919384Z","start_time":"2019-03-04T09:38:34.906867Z"},"_cell_guid":"245887b3-a0dc-498d-900c-dd1c2898d955","_uuid":"40771630994b93eee040c239f1c0e3bf88f13ced","trusted":true},"cell_type":"code","source":"def get_1d_dummy_model(config):\n    # 仅用于调试\n    nclass = config.n_classes\n    #类别个数\n    input_length = config.audio_length\n    #模型输入长度\n    \n    inp = Input(shape=(input_length,1))\n    #keras Input ： 构建模型输入\n    x = GlobalMaxPool1D()(inp)\n    #keras GlobalMaxPool1D : 时序全局最大池化\n    out = Dense(nclass, activation=softmax)(x)\n    #全连接层，输出维度是nclass，激活函数是softmax,输入是x\n\n    model = models.Model(inputs=inp, outputs=out)\n    #keras Model:实例化一个模型\n    opt = optimizers.Adam(config.learning_rate)\n    #keras Adam :设置优化算法\n\n    model.compile(optimizer=opt, loss=losses.categorical_crossentropy, metrics=['acc'])\n    #keras model compile : 本函数编译模型以供训练\n    #opt是优化算法，loss是损失函数,多类的对数损失,metrics指标是准确率\n    \n    return model\n\ndef get_1d_conv_model(config):\n    \n    nclass = config.n_classes\n    #类别个数\n    input_length = config.audio_length\n    #模型输入长度\n    \n    inp = Input(shape=(input_length,1))\n    #设置模型的输入\n    \n    x = Convolution1D(16, 9, activation=relu, padding=\"valid\")(inp)#一维卷积层（即时域卷积）\n    x = Convolution1D(16, 9, activation=relu, padding=\"valid\")(x)#一维卷积层（即时域卷积）\n    x = MaxPool1D(16)(x)#为时域信号施加最大池化\n    x = Dropout(rate=0.1)(x)#随机失活层\n    \n    x = Convolution1D(32, 3, activation=relu, padding=\"valid\")(x)\n    x = Convolution1D(32, 3, activation=relu, padding=\"valid\")(x)\n    x = MaxPool1D(4)(x)\n    x = Dropout(rate=0.1)(x)\n    \n    x = Convolution1D(32, 3, activation=relu, padding=\"valid\")(x)\n    x = Convolution1D(32, 3, activation=relu, padding=\"valid\")(x)\n    x = MaxPool1D(4)(x)\n    x = Dropout(rate=0.1)(x)\n    \n    x = Convolution1D(256, 3, activation=relu, padding=\"valid\")(x)\n    x = Convolution1D(256, 3, activation=relu, padding=\"valid\")(x)\n    x = GlobalMaxPool1D()(x)\n    x = Dropout(rate=0.2)(x)\n\n    x = Dense(64, activation=relu)(x)#全连接层\n    x = Dense(1028, activation=relu)(x)\n    out = Dense(nclass, activation=softmax)(x)#输出层\n\n    model = models.Model(inputs=inp, outputs=out)\n    #keras Model:实例化一个模型\n    opt = optimizers.Adam(config.learning_rate)\n    #keras Adam :设置优化算法\n    \n    model.compile(optimizer=opt, loss=losses.categorical_crossentropy, metrics=['acc'])\n    #keras model compile : 本函数编译模型以供训练\n    #opt是优化算法，loss是损失函数,多类的对数损失,metrics指标是准确率\n    return model","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"2e67aa4a-f2d0-4889-a1da-b6d3217edb5e","_uuid":"32afe89ebdee366de311a6fffb5c49a0e568aaa8"},"cell_type":"markdown","source":"<a id=\"1d_training\"></a>\n#### Training 1D Conv\n训练1D卷积网络"},{"metadata":{"_cell_guid":"a93de421-33be-4104-bcfa-b581cbde3d75","_uuid":"ddbcf58975c5cd7436314a77e5b8f938640bcf34"},"cell_type":"markdown","source":"It is important to convert raw labels to integer indices  \n将原始标签转换为整数索引很重要"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:38:34.954572Z","start_time":"2019-03-04T09:38:34.923630Z"},"_cell_guid":"e9027035-0e77-47dd-8616-113c1cfb37e0","_uuid":"53aca10261dea0b8357e39adb513c7689b7c07ff","trusted":true},"cell_type":"code","source":"LABELS = list(train.label.unique())\n# 原始标签列表\nlabel_idx = {label: i for i, label in enumerate(LABELS)}\n# 字典生成式 ： 构建字典  标签：序号\ntrain.set_index(\"fname\", inplace=True)\n#pandas set_index : 将训练集train的frame列设置为索引列，并保存修改\ntest.set_index(\"fname\", inplace=True)\n#pandas set_index : 将测试集test的frame列设置为索引列，并保存修改\ntrain[\"label_idx\"] = train.label.apply(lambda x: label_idx[x])\n#panda apply : 对每个元素操作。给train新建一列label_idx，值是标签对应的序号。\nif not COMPLETE_RUN:#如果之前的COMPLETE_RUN不为空\n    train = train[:2000]#训练集取前2000个\n    test = test[:2000]#测试集取前2000个","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T09:38:34.963572Z","start_time":"2019-03-04T09:38:34.958277Z"},"_cell_guid":"f2f2dc50-77d3-43ba-bf7f-3c6b39beb67b","_uuid":"604a3c7971599898b5614a67da12da84ab651a55","trusted":true},"cell_type":"code","source":"config = Config(sampling_rate=16000, audio_duration=2, n_folds=10, learning_rate=0.001)\n#配置\nif not COMPLETE_RUN:#如果COMPLETE_RUN不为空。这里缩小了数据的规模。\n    config = Config(sampling_rate=100, audio_duration=1, n_folds=2, max_epochs=1)","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"e31b98ec-cecb-4584-9bbc-bc2748476b49","_uuid":"7a2a5e44d82a2b9e04117b76464225278ec4a1d8"},"cell_type":"markdown","source":"Here is the code for 10-fold training:  \n以下是10折训练的代码：  \n* We use **`from sklearn.cross_validation.StratifiedKFold`** for splitting the trainig data into 10 folds.  \n我们使用sklearn.model_selection.StratifiedKFold将trainig数据分成10份。  \n* We use some Keras callbacks to monitor the training.  \n我们使用一些Keras回调函数来监控训练过程。  \n    * **`ModelCheckpoint`** saves the best weight of our model (using validation data). We use this weight to make test predictions.  \n    ModelCheckpoint保存了我们模型的最佳权重（使用验证数据）。 我们使用此权重进行测试预测。  \n    * **`EarlyStopping`** stops the training once validation loss ceases to decrease  \n    当验证损失函数不再下降，EarlyStopping将停止训练  \n    * **`TensorBoard`** helps us visualize training and validation loss and accuracy.  \n    TensorBoard帮助我们可视化培训和查看损失和准确性。  \n* We fit the model using **`DataGenerator`** for training and validation splits.   \n我们使用DataGenerator生成数据来进行模型拟合，以进行训练集和验证集分割。  \n* We get both training and test predictions and save them as .npy format. We also generate a submission file. For 10-fold CV, the number of prediction files should be 10. We will ensemble these predictions later.  \n我们得到训练和测试预测结果，并将它们保存为.npy格式。 我们还生成一个提交文件。 对于10折交叉验证，预测文件的数量应为10.我们将在稍后集成这些预测。"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T10:02:50.237969Z","start_time":"2019-03-04T09:50:53.467462Z"},"_cell_guid":"e81537d9-d886-4bd5-a923-7efe1aa1812d","_kg_hide-output":true,"_uuid":"1e68d5ae8e431445151c8c7744fadb65fbf692c8","trusted":true},"cell_type":"code","source":"# ```python\n!export HDF5_USE_FILE_LOCKING=FALSE\n#文件锁，多线程时没有这句话可能会报错\n\nPREDICTION_FOLDER = \"predictions_1d_conv\"\n#预测结果文件夹\n\nif not os.path.exists(PREDICTION_FOLDER): #如果不存在这个文件夹\n    os.mkdir(PREDICTION_FOLDER)#那就创建这个文件夹\nif os.path.exists('logs/' + PREDICTION_FOLDER):\n    shutil.rmtree('logs/' + PREDICTION_FOLDER) #删除文件夹\n\nskf = StratifiedKFold(n_splits=config.n_folds).split(train, train.label_idx)\n#keras StratifiedKFold: \n# 将全部训练集S分成k个不相交的子集，假设S中的训练样例个数为m，那么每一个自己有m/k个训练样例，相应的子集为{s1，s2，...，sk}\n# 每次从分好的子集里面，拿出一个作为测试集，其他k-1个作为训练集\n# 在k-1个训练集上训练出学习器模型，把这个模型放到测试集上，得到分类率的平均值，作为该模型或者假设函数的真实分类率\n# skf = StratifiedKFold(n_splits=config.n_folds).split(train, train.label_idx)#这个是新版本的\n\nfor i, (train_split, val_split) in enumerate(skf):\n    #i是第几次拆分，train_split是拆分后训练集的序号，val_split是拆分后测试集的序号\n    train_set = train.iloc[train_split]\n    #pandas iloc : 用整数索引来 取值。这里可以将训练集中的K折拆分训练集选出来\n    val_set = train.iloc[val_split]\n    #pandas iloc : 用整数索引来 取值。这里可以将训练集中的K折拆分测试集选出来\n    checkpoint = ModelCheckpoint('best_%d.h5'%i, monitor='val_loss', verbose=1, save_best_only=True)\n    #keras :该回调函数将在每个epoch训练结束后   自动  保存模型到filepath，monitor：需要监视的值，verbose：信息展示模式，0或1，save_best_only：当设置为True时，将只保存在验证集上性能最好的模型\n    early = EarlyStopping(monitor=\"val_loss\", mode=\"min\", patience=5)\n    #keras :当监测值不再改善时，该回调函数将中止训练.monitor：需要监视的量.在min模式下，如果检测值停止下降则中止训练.patience：当early stop被激活（如发现loss相比上一个epoch训练没有下降），则经过patience个epoch后停止训练。\n    tb = TensorBoard(log_dir='./logs/' + PREDICTION_FOLDER + '/fold_%d'%i, write_graph=True)\n    #keras TensorBoard : 该回调函数是一个可视化的展示器。log_dir：保存日志文件的地址，该文件将被TensorBoard解析以用于可视化.write_graph:是否可视化梯度直方图\n\n    callbacks_list = [checkpoint, early, tb]\n    #回调函数参数列表，用于之后传值\n    \n    print(\"Fold: \", i)\n    print(\"#\"*50)\n    if COMPLETE_RUN:#大训练集\n        model = get_1d_conv_model(config)\n    else:#小训练集\n        model = get_1d_dummy_model(config)\n    #实例化一个数据生成类，得到K折拆分训练集\n    train_generator = DataGenerator(config, '../input/freesound-audio-tagging/audio_train/audio_train/', train_set.index, \n                                    train_set.label_idx, batch_size=64,\n                                    preprocessing_fn=audio_norm)\n    #实例化一个数据生成类，得到K折拆分测试集\n    val_generator = DataGenerator(config, '../input/freesound-audio-tagging/audio_train/audio_train/', val_set.index, \n                                  val_set.label_idx, batch_size=64,\n                                  preprocessing_fn=audio_norm)\n    #训练\n    history = model.fit_generator(train_generator, callbacks=callbacks_list, validation_data=val_generator,\n                                  epochs=config.max_epochs, use_multiprocessing=False, workers=0, max_queue_size=10)\n    #原作者使用的参数是：use_multiprocessing=True，workers=6.但是本地运行会报错，需要对参数做调整，还要把h5py卸载重装2.7.1 版本才不会报错。\n    model.load_weights('best_%d.h5'%i)\n    #keras load_weights : 从hdf5文件中加载所有神经网络层的权重(上面有个自动调用的回调函数用于保存训练的权重)\n    \n    \n    # Save train predictions测试\n    #实例化一个数据生成类，得到原训练集\n    train_generator = DataGenerator(config, '../input/freesound-audio-tagging/audio_train/audio_train/', train.index, batch_size=128,\n                                    preprocessing_fn=audio_norm)\n    #使用前面训练的model去预测训练集\n    predictions = model.predict_generator(train_generator, use_multiprocessing=True, \n                                          workers=6, max_queue_size=20, verbose=1)\n    #用numpy .npy文件保留预测结果\n    np.save(PREDICTION_FOLDER + \"/train_predictions_%d.npy\"%i, predictions)\n    \n    #实例化一个数据生成类，得到原测试集\n    test_generator = DataGenerator(config, '../input/freesound-audio-tagging/audio_test/audio_test/', test.index, batch_size=128,\n                                    preprocessing_fn=audio_norm)\n    #使用前面训练的model去预测测试集\n    predictions = model.predict_generator(test_generator, use_multiprocessing=True, \n                                          workers=6, max_queue_size=20, verbose=1)\n    #用numpy .npy文件保留预测结果\n    np.save(PREDICTION_FOLDER + \"/test_predictions_%d.npy\"%i, predictions)\n    \n    \n    # Make a submission file生成提交文件\n    \n    top_3 = np.array(LABELS)[np.argsort(-predictions, axis=1)[:, :3]]\n    #LABELS -> top_3  :  (2000,41) -> (2000,3)\n    #numpy : 在每行，把predictions从大到小排序，取前三个的索引，根据索引，选出LABELS每行中对应的数据(类别)。即选出每个样本预测概率最大的三个类别。\n    predicted_labels = [' '.join(list(x)) for x in top_3]\n    #python join : 把top_3每行的3个类别，以空格隔开，组成一个字符串。(2000,3) -> (2000,)\n    test['label'] = predicted_labels\n    #pandas : test新增'label'一列，数据是predicted_labels\n    test[['label']].to_csv(PREDICTION_FOLDER + \"/predictions_%d.csv\"%i)\n    #将结果保存到.csv文件\n    # 双层括号返回的是DataFrame的形式（带label的表头且含index）\n    \n#     ```","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"488df4a9-b090-4397-a649-2e94f9ee82ad","_uuid":"2afcdcf0f77f8685f57e2d119ec0cc650b7255d7"},"cell_type":"markdown","source":"<a id=\"1d_ensembling\"></a>\n#### Ensembling 1D Conv Predictions  \n一维Conv模型预测值集成  \nNow that we have trained our model, it is time average the predictions of 10-folds. We will try Geometric Mean averaging and see what will be our Public LB score.  \n现在我们已经训练了我们的模型，现在需要平均10折(这里是2折)的预测结果。 我们将尝试几何平均值(n个变量值连乘积后开n次方)，并查看我们的公共LB(kaggle LeaderBoard)得分。"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T11:31:16.835787Z","start_time":"2019-03-04T11:31:16.760469Z"},"_cell_guid":"4050aede-678b-4f9e-bb95-e70f79e4f6bd","_kg_hide-output":true,"_uuid":"bfdddecb92be07d06e71d25b1812d064a0cee66d","trusted":true},"cell_type":"code","source":"pred_list = []\n\nfor i in range(2):\n    #括号中的数字是数据集拆分的次数\n    pred_list.append(np.load(\"../input/freesound-prediction-file/test_predictions_%d.npy\"%i))\n    #取第i个测试结果，追加到pred_list列表中.最后的维度类似于(2, 2000, 41)\nprediction = np.ones_like(pred_list[0])\n#numpy ones_like : 返回与给定数组具有相同形状(2000, 41)和类型的用1填充的数组。\n\n#求几何平均值（集成之前的多个测试文件）\nfor pred in pred_list:\n    #pred的维度是(2000, 41)\n    prediction = prediction*pred  #   pred[0]与pred[1]  对应元素相乘\nprediction = prediction**(1./len(pred_list))\n# 几何平均 https://en.wikipedia.org/wiki/Geometric_mean\n\n# Make a submission file  制作最后的提交文件\ntop_3 = np.array(LABELS)[np.argsort(-prediction, axis=1)[:, :3]]\n#LABELS -> top_3  :  (2000,41) -> (2000,3)\n#numpy : 在每行，把predictions从大到小排序，取前三个的索引，根据索引，选出LABELS每行中对应的数据(类别)。\n# 即选出每个样本预测概率最大的三个类别。\n\npredicted_labels = [' '.join(list(x)) for x in top_3]\n#python join : 把top_3每行的3个类别，以空格隔开，组成一个字符串。(2000,3) -> (2000,)， 这是最后的提交格式哦\n\n#2000\ntest = pd.read_csv('../input/freesound-audio-tagging/sample_submission.csv')\n#pandas read_csv : 读取kaggle给的sample_submission.csv\n\n# test.set_index(\"fname\", inplace=True)\ntest['label'] = predicted_labels\n#test新增一列label，每一行的值与predicted_labels对应\n\ntest[['fname', 'label']].to_csv(\"1d_conv_ensembled_submission.csv\", index=False)\n#pandas to_cvs : 将DataFrame保存为.csv文件","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"8c437de1-ecc0-4c72-9595-c689c101a72c","_uuid":"40ef0374888d1453eed07c8daa18f231c12ef36d"},"cell_type":"markdown","source":"<a id=\"intro_mfcc\"></a>\n## <center> 3. Introuction to MFCC 使用MFCC特征从频域分类\n\nAs we have seen in the previous section, our Deep Learning models are powerful enough to classify sounds from the raw audio. We do not require any complex feature engineering. But before the Deep Learning era, people developed techniques to extract features from audio signals. It turns out that these techniques are still useful. One such technique is computing the MFCC (Mel Frquency Cepstral Coefficients) from the raw audio. Before we jump to MFCC, let's talk about extracting features from the sound.  \n正如我们在上一节中看到的，我们的深度学习模型足够强大，可以对原始音频中的声音进行分类。我们不需要任何复杂的特征工程。但在深度学习时代之前，人们开发了从音频信号中提取特征的技术。事实证明，这些技术仍然有用。一种这样的技术是从原始音频计算MFCC（Mel Frquency Cepstral Coefficients梅尔频率倒谱系数）。在我们跳到MFCC之前，让我们谈谈从声音中提取特征。  \n\nIf we just want to classify some sound, we should build features that are **speaker independent**. Any feature that only gives information about the speaker (like the pitch of their voice) will not be helpful for classification. In other words, we should extract features that depend on the \"content\" of the audio rather than the nature of the speaker. Also, a good feature extraction technique should mimic the human speech perception. We don't hear loudness on a linear scale. If we want to double the perceived loudness of a sound, we have to put 8 times as much energy into it. Instead of a linear scale, our perception system uses a log scale.   \n如果我们只想对某些声音进行分类，我们应该构建与扬声器无关的特征。任何只提供有关扬声器信息的功能（如声音的音高）对分类没有帮助。换句话说，我们应该提取依赖于音频“内容”而不是话筒的特征。此外，良好的特征提取技术应该模仿人类语音感知。我们听到的音阶的响度不是线性的。如果我们想要将声音的感知响度加倍，我们必须将8倍的能量投入其中。我们的感知系统使用log函数而不是线性函数。  \n\nTaking these things into account, Davis and Mermelstein came up with MFCC in the 1980's. MFCC mimics the logarithmic perception of loudness and pitch of human auditory system and tries to eliminate speaker dependent characteristics by excluding the fundamental frequency and their harmonics. The underlying mathematics is quite complicated and we will skip that. For those interested, here is the [detailed explanation](http://practicalcryptography.com/miscellaneous/machine-learning/guide-mel-frequency-cepstral-coefficients-mfccs/).  \n考虑到这些因素，戴维斯和梅尔斯坦在20世纪80年代提出了MFCC。 MFCC模仿人类听觉系统的响度和音高的对数感知，并试图通过排除基频和它们的谐波来消除说话者相关的特征。基础数学非常复杂，我们将跳过这一点。对于那些感兴趣的人，这里有详细的解释。\n\n![http://recognize-speech.com/images/FeatureExtraction/MFCC/MFCC_Flowchart.png](http://recognize-speech.com/images/FeatureExtraction/MFCC/MFCC_Flowchart.png)\n\n<a id=\"librosa_mfcc\"></a>\n#### Generating MFCC using Librosa使用Librosa库生成MFCC  \nThe library librosa has a function to calculate MFCC. Let's compute the MFCC of an audio file and visualize it.  \n库librosa具有计算MFCC的功能。让我们计算音频文件的MFCC并将其可视化。\n\nhttp://recognize-speech.com/images/FeatureExtraction/MFCC/MFCC_Flowchart.png"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T11:32:39.385180Z","start_time":"2019-03-04T11:32:39.159802Z"},"_cell_guid":"dcb2a6e7-b086-4d1a-94a4-215f2cb101d0","_uuid":"2f8dfd08f109ababeaca9ce900b68b8a716d28b7","trusted":true},"cell_type":"code","source":"import librosa\n#音频处理库\nSAMPLE_RATE = 44100\n#采样频率\nfname = '../input/freesound-audio-tagging/audio_train/audio_train/' + '00044347.wav'   # Hi-hat鼓\n#一个wav文件的地址\n\nwav, _ = librosa.core.load(fname, sr=SAMPLE_RATE)\n#librosa.core.load : 读取音频文件并取样\n#返回值data是np.ndarray形式的音频序列数据，sr是采样频率，res_type是快速类型。\n\nwav = wav[:2*44100]\n#取前2*44100帧","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T11:32:39.632823Z","start_time":"2019-03-04T11:32:39.390250Z"},"_cell_guid":"6250242e-e3c5-4cb9-8405-43d3279dada1","_kg_hide-output":true,"_uuid":"7498089442d866816aabc85234a8a5546c5e58da","trusted":true},"cell_type":"code","source":"mfcc = librosa.feature.mfcc(wav, sr = SAMPLE_RATE, n_mfcc=40)\n#以numpy_ndarray的形式，返回梅尔频率倒谱系数\nmfcc.shape","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-06T08:35:03.059785Z","start_time":"2019-03-06T08:35:01.882603Z"},"trusted":true},"cell_type":"code","source":"plt.figure(figsize=(16, 4))\nplt.imshow(mfcc, cmap='hot', interpolation='nearest');","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"5015b22f-5de8-4a86-aef4-074bf90023aa","_uuid":"59502f44b22674250a047e89b610867d6c6306c3"},"cell_type":"markdown","source":"<a id=\"2d_model_building\"></a>\n## <center>4. Building a Model using MFCC\n\nWe will build now build a 2D Convolutional model using MFCC.   \n我们现在将使用MFCC构建2D卷积模型。"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T11:32:40.657456Z","start_time":"2019-03-04T11:32:40.616298Z"},"_cell_guid":"384fe65d-fe10-4eee-826c-75c4dffcfa2d","_kg_hide-output":true,"_uuid":"ed54039a4e0b91d10f603799feb8166404bbceec","trusted":true},"cell_type":"code","source":"from keras.layers import (Convolution2D, GlobalAveragePooling2D, BatchNormalization, Flatten,\n                          GlobalMaxPool2D, MaxPool2D, concatenate, Activation)\n#keras layers: keras的神经网络层\n#keras Convolution2D : 二维卷积层对二维输入进行滑动窗卷积\n#keras GlobalAveragePooling2D : 为空域信号施加全局平均值池化\n#keras BatchNormalization : 该层在每个batch上将前一层的激活值重新规范化，即使得其输出数据的均值接近0，其标准差接近1\n#keras Flatten : Flatten层用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。\n#keras GlobalMaxPool2D : 为空域信号施加全局最大值池化\n#keras MaxPool2D ： 为空域信号施加最大值池化\n#keras concatenate : 融合层\n#keeas Activation : 激活层\n\nfrom keras.utils import Sequence, to_categorical\n#keras Sequence :序列数据的基类，例如一个数据集\n#keras to_categorical：将类别向量(从0到nb_classes的整数向量)映射为二进制类别矩阵\n\nfrom keras import backend as K\n#Keras后端","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T11:32:40.696903Z","start_time":"2019-03-04T11:32:40.664797Z"},"_cell_guid":"97d07753-d78d-465d-936d-7f03eaf1def1","_uuid":"0b2ac601f52ae4ed9dc849fcd095ab94cfe878fe","trusted":true},"cell_type":"code","source":"#测试模型\ndef get_2d_dummy_model(config):\n    \n    nclass = config.n_classes\n    #类别数\n    inp = Input(shape=(config.dim[0],config.dim[1],1))\n    #keras Input : 模型输入\n    x = GlobalMaxPool2D()(inp)\n    #keras GlovalMaxPool2D : 为空域信号施加全局最大值池化\n    out = Dense(nclass, activation=softmax)(x)\n    #keras Dense : 全连接层\n    model = models.Model(inputs=inp, outputs=out)\n    #keras Model:实例化一个模型\n    opt = optimizers.Adam(config.learning_rate)\n    #keras optimizers : 优化器\n    model.compile(optimizer=opt, loss=losses.categorical_crossentropy, metrics=['acc'])\n    #keras model compile : 本函数编译模型以供训练\n    #opt是优化算法，loss是损失函数,多类的对数损失,metrics指标是准确率\n    return model\n\n#实际用的模型\ndef get_2d_conv_model(config):\n    \n    nclass = config.n_classes\n    #类别数\n    inp = Input(shape=(config.dim[0],config.dim[1],1))\n    #keras Input : 模型输入\n    x = Convolution2D(32, (4,10), padding=\"same\")(inp)\n    #keras Convolution2D : 二维卷积层对二维输入进行滑动窗卷积\n    x = BatchNormalization()(x)\n    #keras BatchNormalization ： 该层在每个batch上将前一层的激活值重新规范化，即使得其输出数据的均值接近0，其标准差接近1\n    x = Activation(\"relu\")(x)\n    #keras Activation : 激活层\n    x = MaxPool2D()(x)\n    #keras MaxPool2D : 为空域信号施加最大值池化\n    \n    x = Convolution2D(32, (4,10), padding=\"same\")(x)\n    x = BatchNormalization()(x)\n    x = Activation(\"relu\")(x)\n    x = MaxPool2D()(x)\n    \n    x = Convolution2D(32, (4,10), padding=\"same\")(x)\n    x = BatchNormalization()(x)\n    x = Activation(\"relu\")(x)\n    x = MaxPool2D()(x)\n    \n    x = Convolution2D(32, (4,10), padding=\"same\")(x)\n    x = BatchNormalization()(x)\n    x = Activation(\"relu\")(x)\n    x = MaxPool2D()(x)\n\n    x = Flatten()(x)\n    #keras Flatten : Flatten层用来将输入“压平”，即把多维的输入一维化，常用在从卷积层到全连接层的过渡。    \n    x = Dense(64)(x)\n    #keras Dense : 全连接层\n    x = BatchNormalization()(x)\n    x = Activation(\"relu\")(x)\n    out = Dense(nclass, activation=softmax)(x)\n\n    model = models.Model(inputs=inp, outputs=out)\n    opt = optimizers.Adam(config.learning_rate)\n\n    model.compile(optimizer=opt, loss=losses.categorical_crossentropy, metrics=['acc'])\n    return model","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"c0c823de-9971-4247-9501-dc74d2f95d8e","_uuid":"d88e90fdc36c77c10ecc8f674d6fd39c8e4d78fb"},"cell_type":"markdown","source":"<a id=\"2d_data\"></a>\n### Preparing data准备准据"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T11:32:40.715238Z","start_time":"2019-03-04T11:32:40.702962Z"},"_cell_guid":"eb5aef7d-669b-4cde-9e09-a2bfaa379cc9","_uuid":"70b8cd145ae3838c7974fe257403c8c7fbc8552a","trusted":true},"cell_type":"code","source":"config = Config(sampling_rate=44100, audio_duration=2, n_folds=10, \n                learning_rate=0.001, use_mfcc=True, n_mfcc=40)\n#实例化配置类\nif not COMPLETE_RUN:\n    #如果不是完全运行，减小训练量\n    config = Config(sampling_rate=44100, audio_duration=2, n_folds=2, \n                    max_epochs=1, use_mfcc=True, n_mfcc=40)","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T11:32:40.748236Z","start_time":"2019-03-04T11:32:40.720379Z"},"_cell_guid":"5b9b1c9b-7e02-46f3-96f6-67ebc9bf9132","_uuid":"5242e943f1bc1154d19c03c361a826553c811cfe","trusted":true},"cell_type":"code","source":"#一些预处理操作，返回梅尔频率倒谱系数\ndef prepare_data(df, config, data_dir):\n    X = np.empty(shape=(df.shape[0], config.dim[0], config.dim[1], 1))\n    #numpy empty : 用零构建指定形状的数组\n    input_length = config.audio_length\n    #输入的长度\n    for i, fname in enumerate(df.index):\n        #pandas index : df.index是文件名\n        print(fname)\n        file_path = data_dir + fname\n        #文件的路径\n        data, _ = librosa.core.load(file_path, sr=config.sampling_rate, res_type=\"kaiser_fast\")\n        #读取音频文件并取样\n        #返回值data是np.ndarray形式的音频序列数据，sr是采样频率，res_type是快速类型。\n\n        # Random offset / Padding\n        #如果音频长度大于模型的输入长度    过长 从中取出指定长度的音频 \n        if len(data) > input_length:\n            max_offset = len(data) - input_length\n            # 数据长度比模型输入长度长多少\n            offset = np.random.randint(max_offset)\n            #在(0,max_offset)之间随机生成一个整数\n            data = data[offset:(input_length+offset)]\n            #随机截取一段长度为input_length的音频\n        else:\n            # 如果音频过短，补成指定长度\n            if input_length > len(data):\n                max_offset = input_length - len(data)\n                # 模型输入长度比数据长度长多少\n                offset = np.random.randint(max_offset)\n                #在(0,max_offset)之间随机生成一个整数\n            else:\n                offset = 0\n                #如果相等，偏移量为0\n            data = np.pad(data, (offset, input_length - len(data) - offset), \"constant\")\n            #nimpy pad : 在数组前后填充常数。数组原本长度是len(data)，在前面随机填充offset个常数，在后面随机填充input_length - len(data) - offset个常数，总长度变为input_length\n\n        data = librosa.feature.mfcc(data, sr=config.sampling_rate, n_mfcc=config.n_mfcc)\n        #以numpy_ndarray的形式，返回梅尔频率倒谱系数\n        data = np.expand_dims(data, axis=-1)\n        #在数组最后添加一个维度\n        X[i,] = data\n        #x是模型的输入\n        #X第i个元素 为 第i个处理之后的data.\n    return X","execution_count":null,"outputs":[]},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T12:02:24.236699Z","start_time":"2019-03-04T12:00:00.516544Z"},"_cell_guid":"c9910de1-388b-470e-8908-6df548f1b866","_uuid":"bb3bc487b52a549a856807dd838a4f6cd209917d","trusted":true},"cell_type":"code","source":"# ```python 这里会生成很多废话，我不知道怎么关，耐心翻吧少年\nX_train = prepare_data(train, config, '../input/freesound-audio-tagging/audio_train/audio_train/')\n#得到处理好的训练集\ntest.set_index(\"fname\", inplace=True)\n#不加上面这句话会报错。\n#pandas set_index : 将测试集test的frame列设置为索引列，并保存修改\nX_test = prepare_data(test, config, '../input/freesound-audio-tagging/audio_test/audio_test/')\n#得到处理好的测试集\ny_train = to_categorical(train.label_idx, num_classes=config.n_classes)\n#将类别向量(从0到nb_classes的整数向量)映射为二进制类别矩阵\nfan='julyfan'\nfan\n# ```","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"a0e0b17b-d2f8-47f8-9b4d-fff3b2761dde","_uuid":"89e8bd3dc6d1f432309e668685fb98d1ce866e95"},"cell_type":"markdown","source":"<a id=\"2d_normalization\"></a>\n#### Normalization  \n归一化"},{"metadata":{},"cell_type":"markdown","source":"线性函数归一化（摘自百面机器学习）  \n![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"_cell_guid":"928b0993-7799-4b75-bef8-c1df3755632e","_uuid":"60b6d9dfcb25eb9b3cef7e05675d67b104e24b31","trusted":true},"cell_type":"code","source":"#这里关闭注释，就是归一化\n# mean = np.mean(X_train, axis=0)#均值\n# std = np.std(X_train, axis=0)#方差\n\n# X_train = (X_train - mean)/std#训练集归一化\n# X_test = (X_test - mean)/std#测试集归一化\n","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"af8afd09-66bf-4618-ad95-d70db35b90ec","_uuid":"b70fea949114595111c39f9f64fb1752603e3fdf"},"cell_type":"markdown","source":"<a id=\"2d_training\"></a>\n#### Training 2D Conv on MFCC 训练，生成多个提交文件(K折)"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-04T12:08:01.980172Z","start_time":"2019-03-04T12:03:32.025781Z"},"_cell_guid":"10fb7477-8122-49fb-be81-1adb7aa45c7f","_uuid":"ab0f2bc7e7bbaced3eb2e4c3acb7c7c63aa73681","trusted":true},"cell_type":"code","source":"# ```python\nPREDICTION_FOLDER = \"predictions_2d_conv\"\n#文件夹的名字\nif not os.path.exists(PREDICTION_FOLDER):#如果不存在这个文件夹\n    os.mkdir(PREDICTION_FOLDER)#那就创建这个文件夹\nif os.path.exists('logs/' + PREDICTION_FOLDER):\n    shutil.rmtree('logs/' + PREDICTION_FOLDER)#删除目录\n\n# skf = StratifiedKFold(train.label_idx, n_folds=config.n_folds) 作者写的代码已经被移除了\nskf = StratifiedKFold(n_splits=config.n_folds).split(train, train.label_idx)\n# keras StratifiedKFold: \n# 将全部训练集S分成k个不相交的子集，假设S中的训练样例个数为m，那么每一个自己有m/k个训练样例，相应的子集为{s1，s2，...，sk}\n# 每次从分好的子集里面，拿出一个作为测试集，其他k-1个作为训练集\n# 在k-1个训练集上训练出学习器模型，把这个模型放到测试集上，得到分类率的平均值，作为该模型或者假设函数的真实分类率\n# skf = StratifiedKFold(n_splits=config.n_folds).split(train, train.label_idx)#这个是新版本的\n\nfor i, (train_split, val_split) in enumerate(skf):\n    #i是第几次拆分，train_split是拆分后训练集的序号，val_split是拆分后测试集的序号\n    K.clear_session()\n    #keras clear_session : 结束当前的TF计算图，并新建一个。有效的避免模型/层的混乱\n    X, y, X_val, y_val = X_train[train_split], y_train[train_split], X_train[val_split], y_train[val_split]\n    #K折分割训练集。\n    checkpoint = ModelCheckpoint('best_%d.h5'%i, monitor='val_loss', verbose=1, save_best_only=True)\n    #keras ModelCheckpoint : 该回调函数将在每个epoch训练结束后  自动   保存模型到filepath，monitor：需要监视的值，verbose：信息展示模式，0或1，save_best_only：当设置为True时，将只保存在验证集上性能最好的模型\n    early = EarlyStopping(monitor=\"val_loss\", mode=\"min\", patience=5)\n    #keras EarlyStopping : 当监测值不再改善时，该回调函数将中止训练.monitor：需要监视的量.在min模式下，如果检测值停止下降则中止训练.patience：当early stop被激活（如发现loss相比上一个epoch训练没有下降），则经过patience个epoch后停止训练。\n    tb = TensorBoard(log_dir='./logs/' + PREDICTION_FOLDER + '/fold_%i'%i, write_graph=True)\n    #keras TensorBoard : 该回调函数是一个可视化的展示器。log_dir：保存日志文件的地址，该文件将被TensorBoard解析以用于可视化.write_graph:是否可视化梯度直方图\n    callbacks_list = [checkpoint, early, tb]\n    #回调函数参数列表，用于之后传值\n    print(\"#\"*50)\n    print(\"Fold: \", i)\n    model = get_2d_conv_model(config)\n    #调用自定义函数，构造复杂模型\n    history = model.fit(X, y, validation_data=(X_val, y_val), callbacks=callbacks_list, \n                        batch_size=64, epochs=config.max_epochs)\n    #训练\n    \n    model.load_weights('best_%d.h5'%i)\n    #keras load_weights : 从hdf5文件中加载所有神经网络层的权重\n    \n    # Save train predictions\n    #使用前面训练的model去预测测试集\n    predictions = model.predict(X_train, batch_size=64, verbose=1)\n    #用numpy .npy文件保留预测结果\n    np.save(PREDICTION_FOLDER + \"/train_predictions_%d.npy\"%i, predictions)\n    #使用前面训练的model去预测测试集\n    # Save test predictions\n    predictions = model.predict(X_test, batch_size=64, verbose=1)\n    #用numpy .npy文件保留预测结果\n    np.save(PREDICTION_FOLDER + \"/test_predictions_%d.npy\"%i, predictions)\n\n    # Make a submission file制作提价文件\n    top_3 = np.array(LABELS)[np.argsort(-predictions, axis=1)[:, :3]]\n    #LABELS -> top_3  :  (2000,41) -> (2000,3)\n    #numpy : 在每行，把predictions从大到小排序，取前三个的索引，根据索引，选出LABELS每行中对应的数据(类别)。\n    #即选出每个样本预测概率最大的三个类别。\n    \n    predicted_labels = [' '.join(list(x)) for x in top_3]\n    #python join : 把top_3每行的3个类别，以空格隔开，组成一个字符串。(2000,3) -> (2000,)\n    \n    test['label'] = predicted_labels\n    #test新增一列label，值一行的值与predicted_labels对应\n    test[['label']].to_csv(PREDICTION_FOLDER + \"/predictions_%d.csv\"%i)\n    #pandas to_cvs : 将DataFrame保存为.csv文件\n# ```","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"4bd794b7-c09e-42d6-8f8a-158758921273","_uuid":"b4421687f65fd8068c04fcdfdb419bf4f08c5f2c"},"cell_type":"markdown","source":"<a id=\"2d_ensembling\"></a>\n#### Ensembling 2D Conv Predictions\n二维Convk折预测值集成"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-05T01:41:12.991077Z","start_time":"2019-03-05T01:41:12.781261Z"},"_cell_guid":"8c253178-6cde-4bad-835d-d09484f381ed","_uuid":"e6868eb538b9fed874fcb02183d2edd348d38b5f","trusted":true},"cell_type":"code","source":"pred_list = []\n\nfor i in range(2):\n    #括号中的数字是数据集拆分的次数\n    pred_list.append(np.load(\"../input/freesound-prediction-file/test_predictions_%d.npy\"%i))\n    #取第i个测试结果，追加到pred_list列表中.最后的维度类似于(2, 9400, 41)\nprediction = np.ones_like(pred_list[0])\n#numpy ones_like : 返回与给定数组具有相同形状(9400, 41)和类型的用1填充的数组。\n\n#求几何平均值\nfor pred in pred_list:\n    #pred的维度是(9400, 41)\n    prediction = prediction*pred #pred[0] pred[1] 对应元素相乘\nprediction = prediction**(1./len(pred_list))\n#求几何平均\n\n# Make a submission file制作提价文件\ntop_3 = np.array(LABELS)[np.argsort(-prediction, axis=1)[:, :3]]\n#LABELS -> top_3  :  (9400,41) -> (9400,3)\n#numpy : 在每行，把predictions从大到小排序，取前三个的索引，根据索引，选出LABELS每行中对应的数据(类别)。\n# 即选出每个样本预测概率最大的三个类别。\n\npredicted_labels = [' '.join(list(x)) for x in top_3]\n#python join : 把top_3每行的3个类别，以空格隔开，组成一个字符串。(9400,3) -> (9400,)\n\n#9400\ntest = pd.read_csv('../input/freesound-audio-tagging/sample_submission.csv')\n#pandas read_csv : 读取kaggle给的sample_submission.csv\n\n# test.set_index(\"fname\", inplace=True)\ntest['label'] = predicted_labels\n#test新增一列label，每一行的值与predicted_labels对应\n\ntest[['fname', 'label']].to_csv(\"1d_conv_ensembled_submission.csv\", index=False)\n#pandas to_cvs : 将DataFrame保存为.csv文件","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"b67760f2-f8cd-498a-b340-4910d8c443d3","_uuid":"38feef2350dfa3c099bd6fb2e1a0b921716606a8"},"cell_type":"markdown","source":"<a id=\"1d_2d_ensembling\"></a>\n## <center>5. Ensembling 1D Conv and 2D Conv Predictions</center>  \n深度学习方法1维卷积 和 MFCC方法2 的预测值集成"},{"metadata":{"ExecuteTime":{"end_time":"2019-03-05T01:42:19.012814Z","start_time":"2019-03-05T01:42:18.947583Z"},"_cell_guid":"12566257-72a5-4aa3-9e11-763c98489810","_uuid":"448e8f9034d9d43a4642b1f441965b272425ba63","trusted":true},"cell_type":"code","source":"pred_list = []\n# for i in range(10):\n#     pred_list.append(np.load(\"../input/freesound-prediction-data-2d-conv-reduced-lr/test_predictions_%d.npy\"%i))\nfor i in range(2):\n    pred_list.append(np.load(\"../input/freesound-prediction-data-2d-conv-reduced-lr/test_predictions_%d.npy\"%i))\n    #取第i个1d_conv测试结果，追加到pred_list列表中.最后的维度类似于(4, 2000, 41)    \nfor i in range(2):\n    pred_list.append(np.load(\"../input/freesound-prediction-file/test_predictions_%d.npy\"%i))\n    #取第i个2d_conv测试结果，追加到pred_list列表中.最后的维度类似于(4, 2000, 41)    \nprediction = np.ones_like(pred_list[0])\n#numpy ones_like : 返回与给定数组具有相同形状(2000, 41)和类型的用1填充的数组。\n\n#求几何平均值\nfor pred in pred_list:\n    #pred的维度是(2000, 41)\n    prediction = prediction*pred\n    #np * : 对应元素相乘\n    #n个变量值连乘积\nprediction = prediction**(1./len(pred_list))\n#求平均\n\n# Make a submission file制作提价文件\ntop_3 = np.array(LABELS)[np.argsort(-prediction, axis=1)[:, :3]]\n#LABELS -> top_3  :  (2000,41) -> (2000,3)\n#numpy : 在每行，把predictions从大到小排序，取前三个的索引，根据索引，选出LABELS每行中对应的数据(类别)。\n# 即选出每个样本预测概率最大的三个类别。\n\npredicted_labels = [' '.join(list(x)) for x in top_3]\n#python join : 把top_3每行的3个类别，以空格隔开，组成一个字符串。(2000,3) -> (2000,)\n\ntest = pd.read_csv('../input/freesound-audio-tagging/sample_submission.csv')\n#pandas read_csv : 读取kaggle给的sample_submission.csv\n\ntest['label'] = predicted_labels\n#test新增一列label，每一行的值与predicted_labels对应\n\ntest[['fname', 'label']].to_csv(\"1d_2d_ensembled_submission.csv\", index=False)\n#pandas to_cvs : 将DataFrame保存为.csv文件","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"34e4b1a5-49ac-49ff-a9cd-9b341d784e9b","_uuid":"836b4a9008b4a239f3c41d8f3997bd49fa3c2280"},"cell_type":"markdown","source":"<a id=\"conclusion\"></a>\n## <center>Results and Conclusion</center>  \n结果与展望"},{"metadata":{"_cell_guid":"1f6bb71f-f461-414c-90d1-725c03f368ff","_uuid":"01cfbfa163adb3da8b7b7da3310fb9e38ce0d478","collapsed":true},"cell_type":"markdown","source":"So far, we have trained two models. Let's analyze their relative complexity and strength.  \n到目前为止，我们已经训练了两个模型。 让我们分析它们的相对复杂性和好坏。   \n\n\n\n| Model        | Number of Trainable parameters           | Public LB score  |\n| ------------- |:-------------:| -----:|\n| 1D Conv on Raw wave(方法一)      | 360,513 | 0.809 |\n| 2D Conv on MFCC (verified labels only)    | 168,361  |   0.785 |\n| 2D Conv on MFCC(方法二)     | 168,361  |   0.844 |\n| 1D Conv + 2D Conv Ensemble(法1+法二)     | N/A  |   0.895 |\n\n**As we can see, 2D Convolution on MFCC performs better than 1D Convolution on Raw waves.**  \n原作者最终跑出来的结果发现法二MFCC比法一深度学习一维卷积效果更好"},{"metadata":{"_cell_guid":"78397951-3d15-45c1-bc29-17c853d7adf5","_uuid":"b8db90dc506d23d6241c606ca03fd1762f38f36f"},"cell_type":"markdown","source":"## Coming Soon  \n接下来的工作  \n\n1. Data Augmentation数据增强  \n2. Training on Manually Verified Labels在手工验证集上训练"}],"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.7.0"},"toc":{"base_numbering":1,"nav_menu":{},"number_sections":true,"sideBar":true,"skip_h1_title":false,"title_cell":"Table of Contents","title_sidebar":"Contents","toc_cell":false,"toc_position":{},"toc_section_display":true,"toc_window_display":false}},"nbformat":4,"nbformat_minor":1}