{"cells":[{"metadata":{},"cell_type":"markdown","source":"# Freesound Audio Tagging 2019\n## Automatically recognize sounds and apply tags of varying natures"},{"metadata":{},"cell_type":"markdown","source":"Hello everyone, this kernel was developed to show a new approach of signal processing in machine learning.\nThe key here is the Wavelet Transform (WT), more information in [link 1](https://en.wikipedia.org/wiki/Wavelet_packet_decomposition) and [link 2](https://file.scirp.org/pdf/IJCNS20100300011_40520775.pdf). This is a useful tool for the analysis and classification of time-series and signal. There are diferentes implementations of WT: Continuous Wavelet Transform, Discrete Wavelet Transform and Wavelet Packet Decomposition.\n\nIn this kernel, we will use Wavelet Packet Decomposition and Random Forest Classifier.  \n(Only train_curated dataset will be used)"},{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load in \n\nimport numpy as np # linear algebra \nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\nimport os\nfrom tqdm import tqdm, tqdm_notebook\n\nimport matplotlib.pyplot as plt\n\n#Audio\nimport IPython.display as ipd  # To play sound in the notebook\nfrom scipy.io import wavfile\nimport gc\n\n# Parallelization\nfrom joblib import Parallel, delayed\n\n#Classification\nfrom sklearn.model_selection import KFold\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.metrics import label_ranking_average_precision_score\nfrom sklearn.metrics import roc_auc_score\n\n# Signal processing\nimport scipy.stats","execution_count":null,"outputs":[]},{"metadata":{"_cell_guid":"79c7e3d0-c299-4dcb-8224-4455121ee9b0","_uuid":"d629ff2d2480ee46fbb7e2d37f6b5fab8052498a","trusted":true},"cell_type":"code","source":"# Input data files are available in the \"../input/\" directory.\n# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n# PATH=\"../input/Santander/\" \nPATH=\"../input/\" \nprint(os.listdir(PATH))\n# Any results you write to the current directory are saved as output.","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"%%time\ntrain_curated = pd.read_csv(PATH+\"train_curated.csv\")\n# train_noisy = pd.read_csv(PATH+\"train_noisy.csv\")\ntest = pd.read_csv(PATH+\"sample_submission.csv\")","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Preparing data"},{"metadata":{"trusted":true},"cell_type":"code","source":"print('Train curated size:' + format(train_curated.shape))\n# print('Train noisy size:' + format(train_noisy.shape))\nprint('Test size: ' + format(test.shape))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_curated.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#Creating a dictionary of labels\nlabel_columns = list( test.columns[1:] )\nlabel_mapping = dict((label, index) for index, label in enumerate(label_columns))\nlabel_mapping","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def split_and_label(rows_labels):\n    \n    row_labels_list = []\n    for row in rows_labels:\n        row_labels = row.split(',')\n        labels_array = np.zeros((80))\n        \n        for label in row_labels:\n            index = label_mapping[label]\n            labels_array[index] = 1\n        \n        row_labels_list.append(labels_array)\n    \n    return row_labels_list","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_curated_labels = split_and_label(train_curated['labels'])\n# train_noisy_labels   = split_and_label(train_noisy  ['labels'])\nlen(train_curated_labels) #, len(train_noisy_labels)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"for f in label_columns:\n    train_curated[f] = 0.0\n#     train_noisy[f] = 0.0\n\ntrain_curated[label_columns] = train_curated_labels\n# train_noisy[label_columns]   = train_noisy_labels\n\ntrain_curated['num_labels'] = train_curated[label_columns].sum(axis=1)\n# train_noisy['num_labels']   = train_noisy[label_columns].sum(axis=1)\n\ntrain_curated['path'] = PATH+'train_curated/'+train_curated['fname']\n# train_noisy  ['path'] = PATH+'train_noisy/'+train_noisy['fname']\n\ntrain_curated.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# train_noisy.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train = train_curated\n# train = pd.concat([train_curated, train_noisy],axis=0) # Using both datasets\n\ndel train_curated  #, train_noisy\ngc.collect()\n\ntrain.shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train.describe()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Wavelet packet descomposition (WPD)"},{"metadata":{},"cell_type":"markdown","source":"![image.png](attachment:image.png)\nWe will use WPD to Level 6. Where, a total of 64 new signal are obtained. For each new signal, a statistics feature group are obtanied. ","attachments":{"image.png":{"image/png":"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"}}},{"metadata":{"trusted":true},"cell_type":"code","source":"import pywt\nimport scipy as sc","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Zero pading\nUseful information\n[Link 1](http://www.bitweenie.com/listings/fft-zero-padding/)\n[Link 2](https://www.youtube.com/watch?v=ukHTfD37THI)"},{"metadata":{"trusted":true},"cell_type":"code","source":"def zero_padding(data, seconds):\n    fs = 44100  # 2 seconds =  88200 samples    \n    if data.shape[0] < seconds*fs:\n        zeros = np.zeros(seconds*fs - data.shape[0])\n        data = np.concatenate((data, zeros), axis=None)    \n    return data","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"### Feature extraction methods"},{"metadata":{"trusted":true},"cell_type":"code","source":"from collections import defaultdict, Counter\nfrom scipy.stats import kurtosis\nfrom scipy.stats import skew\n\ndef _kurtosis(x):\n    return kurtosis(x)\n\ndef CPT5(x):\n    den = len(x)*np.exp(np.std(x))\n    return sum(np.exp(x))/den\n\ndef SSC(x):\n    x = np.array(x)\n    x = np.append(x[-1], x)\n    x = np.append(x,x[1])\n    xn = x[1:len(x)-1]\n    xn_i2 = x[2:len(x)]    # xn+1 \n    xn_i1 = x[0:len(x)-2]  # xn-1\n    ans = np.heaviside((xn-xn_i1)*(xn-xn_i2),0)\n    return sum(ans[1:]) \n\ndef wave_length(x):\n    x = np.array(x)\n    x = np.append(x[-1], x)\n    x = np.append(x,x[1])\n    xn = x[1:len(x)-1]\n    xn_i2 = x[2:len(x)]    # xn+1 \n    return sum(abs(xn_i2-xn))\n    \ndef norm_entropy(x):\n    tresh = 2\n    return sum(np.power(abs(x),tresh))\n\ndef SRAV(x):    \n    SRA = sum(np.sqrt(abs(x)))\n    return np.power(SRA/len(x),2)\n\ndef mean_abs(x):\n    return sum(abs(x))/len(x)\n\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from scipy.stats import kurtosis\nfrom scipy.stats import skew #skewness\n\ndef calculate_entropy(list_values):\n    counter_values = Counter(list_values).most_common()\n    probabilities = [elem[1]/len(list_values) for elem in counter_values]\n    entropy=scipy.stats.entropy(probabilities)\n    return entropy\n \ndef calculate_statistics(list_values):\n    n5 = np.nanpercentile(list_values, 5)\n    n25 = np.nanpercentile(list_values, 25)\n    n75 = np.nanpercentile(list_values, 75)\n    n95 = np.nanpercentile(list_values, 95)\n    median = np.nanpercentile(list_values, 50)\n    mean = np.nanmean(list_values)\n    std = np.nanstd(list_values)\n    var = np.nanvar(list_values)\n    rms = np.nanmean(np.sqrt(list_values**2))\n    # New features\n    kur = kurtosis(list_values)\n    MeanAbs = mean_abs(list_values)\n    norm_ent = norm_entropy(list_values)\n    skewness = skew(list_values)\n    CPT_5 = CPT5(list_values)\n    SSC_1 = SSC(list_values)\n    WL = wave_length(list_values)\n    SRAV_1 = SRAV(list_values)\n    return [n5, n25, n75, n95, median, mean, std, var, rms, kur, MeanAbs, norm_ent, skewness, CPT_5, SSC_1, WL, SRAV_1]\n \ndef calculate_crossings(list_values):\n    zero_crossing_indices = np.nonzero(np.diff(np.array(list_values) > 0))[0]\n    no_zero_crossings = len(zero_crossing_indices)\n    mean_crossing_indices = np.nonzero(np.diff(np.array(list_values) > np.nanmean(list_values)))[0]\n    no_mean_crossings = len(mean_crossing_indices)\n    return [no_zero_crossings, no_mean_crossings]\n ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def get_features(list_values):\n    entropy = calculate_entropy(list_values)\n    crossings = calculate_crossings(list_values)\n    statistics = calculate_statistics(list_values)\n    return [entropy] + crossings + statistics    ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from sklearn.preprocessing import StandardScaler\n\n\ndef feature_extraction_wpd(path_names, level, seconds):\n    # Sampling rate\n    fs = 44100    \n    corpus = []\n    \n    for fname in tqdm_notebook(path_names):        \n\n        fs, data = wavfile.read(fname)    \n        data = data.astype(float)\n        \n        # Zero padding\n        if data.shape[0] < (seconds*fs):\n            data = zero_padding(data,seconds)\n        elif data.shape[0] > (seconds*fs):\n            data = data[0:seconds*fs]\n        elif data.shape[0] == 0:\n            raise Exception('Lenght of x should not be 0. The value of lenght of x was: {}'.format(data.shape[0]))\n            \n        # Signal standarization\n        data_std = StandardScaler().fit_transform(data.reshape(-1,1)).reshape(1,-1)[0]            \n        \n        # WPD tree\n        wptree = pywt.WaveletPacket(data=data_std, wavelet='db5', mode='symmetric', maxlevel=level)\n        levels = wptree.get_level(level, order = \"freq\")            \n        \n        #Feature extraction for each node\n        features = []        \n        for node in levels:\n            data_wp = node.data\n            # Features group\n            features.extend(get_features(data_wp))\n        corpus.append(features)\n    # Delate first row\n    return np.array(corpus)\n     ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"%%time\npath_names = train.path.values\nlevel = 6\nseconds = 2\nX_train = feature_extraction_wpd(path_names,level,seconds)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"path_names.shape, X_train.shape","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Train set ready!"},{"metadata":{"trusted":true},"cell_type":"code","source":"test.shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"%%time\npath_test = PATH+'test/'\npath_names = path_test + test['fname'].values\nX_test = feature_extraction_wpd(path_names,level, seconds) ","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"Test set ready!"},{"metadata":{},"cell_type":"markdown","source":"Cleaning Nan and Inf values"},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train[~np.isfinite(X_train)] = 0\nX_test[~np.isfinite(X_test)] = 0","execution_count":53,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train = np.float32(X_train)\nX_test = np.float32(X_test)","execution_count":54,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"X_train[~np.isfinite(X_train)] = 0\nX_test[~np.isfinite(X_test)] = 0","execution_count":55,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Classification\n\nInformation about Random Forest classifier:\n[Link](https://medium.com/machine-learning-101/chapter-5-random-forest-classifier-56dc7425c3e1)"},{"metadata":{"trusted":true},"cell_type":"code","source":"n_fold = 5\nfolds = KFold(n_splits=n_fold, shuffle=True, random_state=69)\n\nPREDTRAIN = np.zeros( (X_train.shape[0],80))\nPREDTEST  = np.zeros( (X_test.shape[0],80))\nfor f in range(len(label_columns)):\n    y = train[ label_columns[f]].values\n    oof      = np.zeros( X_train.shape[0] )\n    oof_test = np.zeros( X_test.shape[0] )\n    for fold_, (trn_idx, val_idx) in enumerate(folds.split(X_train,y)):\n        \n        # Random Forest classifier\n        model = RandomForestClassifier(n_estimators=500, random_state=0, n_jobs=-1)\n        model.fit(X_train[trn_idx,:], y[trn_idx])\n        \n        oof[val_idx] = model.predict_proba(X_train[val_idx,:])[:,1] \n        oof_test += model.predict_proba(X_test)[:,1]/5.0\n\n    PREDTRAIN[:,f] = oof    \n    PREDTEST [:,f] = oof_test\n    \n    print( f, str(roc_auc_score( y, oof ))[:6], label_columns[f] )","execution_count":null,"outputs":[{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"0 0.8859 Accelerating_and_revving_and_vroom\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"1 0.9837 Accordion\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"2 0.9698 Acoustic_guitar\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"3 0.9308 Applause\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"4 0.8868 Bark\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"5 0.9444 Bass_drum\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"6 0.9830 Bass_guitar\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"7 0.8491 Bathtub_(filling_or_washing)\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"8 0.9736 Bicycle_bell\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"9 0.8645 Burping_and_eructation\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"10 0.9187 Bus\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"11 0.8385 Buzz\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"},{"output_type":"stream","text":"12 0.9331 Car_passing_by\n","name":"stdout"},{"output_type":"stream","text":"/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n/opt/conda/lib/python3.6/site-packages/numpy/core/_methods.py:36: RuntimeWarning: overflow encountered in reduce\n  return umr_sum(a, axis, dtype, out, keepdims, initial)\n","name":"stderr"}]},{"metadata":{"trusted":true},"cell_type":"code","source":"def calculate_overall_lwlrap_sklearn(truth, scores):\n    \"\"\"Calculate the overall lwlrap using sklearn.metrics.lrap.\"\"\"\n    # sklearn doesn't correctly apply weighting to samples with no labels, so just skip them.\n    sample_weight = np.sum(truth > 0, axis=1)\n    nonzero_weight_sample_indices = np.flatnonzero(sample_weight > 0)\n    overall_lwlrap = label_ranking_average_precision_score(\n        truth[nonzero_weight_sample_indices, :] > 0, \n        scores[nonzero_weight_sample_indices, :], \n        sample_weight=sample_weight[nonzero_weight_sample_indices])\n    return overall_lwlrap\n\nprint( 'CV:', calculate_overall_lwlrap_sklearn( train[label_columns].values, PREDTRAIN ) )","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"PREDTEST.shape, test.shape, X_test.shape","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test[label_columns] = PREDTEST \ntest.to_csv('submission.csv', index=False)\ntest.head()","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"name":"python","version":"3.6.4","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"}},"nbformat":4,"nbformat_minor":1}