{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.10.14","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":8900,"databundleVersionId":862232,"sourceType":"competition"}],"dockerImageVersionId":30786,"isInternetEnabled":false,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"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\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n\n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","execution":{"iopub.status.busy":"2024-10-20T01:48:00.320469Z","iopub.execute_input":"2024-10-20T01:48:00.321197Z","iopub.status.idle":"2024-10-20T01:48:16.400928Z","shell.execute_reply.started":"2024-10-20T01:48:00.321151Z","shell.execute_reply":"2024-10-20T01:48:16.399214Z"},"collapsed":true,"jupyter":{"outputs_hidden":true},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport librosa","metadata":{"execution":{"iopub.status.busy":"2024-10-20T02:12:44.517588Z","iopub.execute_input":"2024-10-20T02:12:44.518033Z","iopub.status.idle":"2024-10-20T02:12:45.812167Z","shell.execute_reply.started":"2024-10-20T02:12:44.517980Z","shell.execute_reply":"2024-10-20T02:12:45.810962Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Функции для извлечения признаков из аудио файлов\n\n* `feature_chromagram` извлекает хромограмму\n* `feature_chromagram_stat` извлекает характеристики хромограммы: среднее, СКО, минимум и максимум\n* `feature_melspectrogram` извелкает мел-спектрограмму, используется 128 частотных полос\n* `feature_mfcc` извлекает 20 мел-кепстральных коэффициентов\n* `feature_mfcc_stat` извлекает характеристики мел-кепстральных коэффициентов: среднее, СКО, минимум и максимум\n* `feature_zero_crossing_rate` извлекает характеристики скорости пересечения нуля\n* `feature_spectral_rolloff` извлекает характеристики спектрального спада\n* `feature_spectral_centroid` извлекает характеристики спектрального центроила","metadata":{}},{"cell_type":"code","source":"def feature_chromagram(waveform, sample_rate):\n    stft_spectrogram=np.abs(librosa.stft(waveform))\n    chromagram=np.mean(librosa.feature.chroma_stft(S=stft_spectrogram, sr=sample_rate).T,axis=0)\n    return chromagram\n\ndef feature_chromagram_stat(waveform, sample_rate):\n    stft_spectrogram=np.abs(librosa.stft(waveform))\n    chromagram=np.mean(librosa.feature.chroma_stft(S=stft_spectrogram, sr=sample_rate).T,axis=0)\n    return np.array([\n        np.mean(chromagram),\n        np.std(chromagram),\n        np.max(chromagram),\n        np.min(chromagram),\n    ])\n\ndef feature_melspectrogram(waveform, sample_rate):\n    melspectrogram=np.mean(librosa.feature.melspectrogram(y=waveform, sr=sample_rate, n_mels=128, fmax=8000).T,axis=0)\n    return melspectrogram\n\ndef feature_mfcc(waveform, sample_rate):\n    mfcc_coefficients=np.mean(librosa.feature.mfcc(y=waveform, sr=sample_rate, n_mfcc=20).T, axis=0) \n    return mfcc_coefficients\n\ndef feature_mfcc_stat(waveform, sample_rate):\n    mfcc_coefficients=np.mean(librosa.feature.mfcc(y=waveform, sr=sample_rate, n_mfcc=20).T, axis=0) \n    return np.array([\n        np.mean(mfcc_coefficients),\n        np.std(mfcc_coefficients),\n        np.max(mfcc_coefficients),\n        np.min(mfcc_coefficients),\n    ])\n\ndef feature_zero_crossing_rate(waveform, sample_rate):\n    try:\n        zero_rate = librosa.feature.zero_crossing_rate(y=waveform).T\n    except ValueError as e:\n        print(\"Bad file, error\", e)\n        return np.array([0, 0, 0, 0])\n    return np.array([\n        np.mean(zero_rate),\n        np.std(zero_rate),\n        np.max(zero_rate),\n        np.min(zero_rate),\n    ])\n\ndef feature_spectral_rolloff(waveform, sample_rate):\n    spectral_rolloff = librosa.feature.spectral_rolloff(y=waveform, sr=sample_rate).T\n    return np.array([\n        np.mean(spectral_rolloff),\n        np.std(spectral_rolloff),\n        np.max(spectral_rolloff),\n        np.min(spectral_rolloff),\n    ])\n\ndef feature_spectral_centroid(waveform, sample_rate):\n    spectral_centroid = librosa.feature.spectral_centroid(y=waveform, sr=sample_rate).T\n    return np.array([\n        np.mean(spectral_centroid),\n        np.std(spectral_centroid),\n        np.max(spectral_centroid),\n        np.min(spectral_centroid),\n    ])\n","metadata":{"execution":{"iopub.status.busy":"2024-10-20T02:13:02.396936Z","iopub.execute_input":"2024-10-20T02:13:02.397532Z","iopub.status.idle":"2024-10-20T02:13:02.421416Z","shell.execute_reply.started":"2024-10-20T02:13:02.397477Z","shell.execute_reply":"2024-10-20T02:13:02.420199Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Загрузим и посмотрим данные\ntrain_data = pd.read_csv(\"/kaggle/input/freesound-audio-tagging/train_post_competition.csv\")\ntrain_data","metadata":{"execution":{"iopub.status.busy":"2024-10-20T02:13:06.345415Z","iopub.execute_input":"2024-10-20T02:13:06.346260Z","iopub.status.idle":"2024-10-20T02:13:06.409194Z","shell.execute_reply.started":"2024-10-20T02:13:06.346212Z","shell.execute_reply":"2024-10-20T02:13:06.408012Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"from sklearn import preprocessing\n\n\n# Закодируем текстовые метки в числа\ntrain_data[\"int_label\"] = preprocessing.LabelEncoder().fit_transform(train_data[\"label\"])\ntrain_data[\"int_label\"].unique()","metadata":{"execution":{"iopub.status.busy":"2024-10-20T02:13:35.111200Z","iopub.execute_input":"2024-10-20T02:13:35.111702Z","iopub.status.idle":"2024-10-20T02:13:35.724819Z","shell.execute_reply.started":"2024-10-20T02:13:35.111657Z","shell.execute_reply":"2024-10-20T02:13:35.723624Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Сделаем кэш для метрик, чтобы не обрабатывать данные лишний раз\ntrain_cache = {}","metadata":{"execution":{"iopub.status.busy":"2024-10-20T02:14:39.664028Z","iopub.execute_input":"2024-10-20T02:14:39.664781Z","iopub.status.idle":"2024-10-20T02:14:39.671294Z","shell.execute_reply.started":"2024-10-20T02:14:39.664718Z","shell.execute_reply":"2024-10-20T02:14:39.669653Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Функции для загрузки данных\n\n## `load_train_data`\n\nЗагружает данные и сразу же обрабатывает их по одной из функцией для извлечения признаков. `FeatureType` -- перечисление для удобства обозначения признаков. Если обработанные данные уже есть в кэше, то они берутся из него, а не обрабатываются заново.\n\n## `load_train_data_multifeature`\n\nАналогично `load_train_data`, только загружает несколько признаков и соединяет их в единый вектор признаков. Внутри себя вызывает `load_train_data`, поэтому кэш также используется","metadata":{}},{"cell_type":"code","source":"from enum import Enum, auto\n\nclass FeatureType(Enum):\n    Chromogram = auto()\n    ChromogramStat = auto()\n    MelSpectrogram = auto()\n    MFCC = auto()\n    MFCC_STAT = auto()\n    ZeroCrossingRate = auto()\n    SpectralRolloff = auto()\n    SpectralCentroid = auto()\n\n\nTYPE_TO_FUNC = {\n    FeatureType.Chromogram: feature_chromagram,\n    FeatureType.ChromogramStat: feature_chromagram_stat,\n    FeatureType.MelSpectrogram: feature_melspectrogram,\n    FeatureType.MFCC: feature_mfcc,\n    FeatureType.MFCC_STAT: feature_mfcc_stat,\n    FeatureType.ZeroCrossingRate: feature_zero_crossing_rate,\n    FeatureType.SpectralRolloff: feature_spectral_rolloff,\n    FeatureType.SpectralCentroid: feature_spectral_centroid,\n}\n\n\ndef load_train_data(dirname: str, feature_type: FeatureType, df: pd.DataFrame):\n    ffunc = TYPE_TO_FUNC[feature_type]\n    features = []\n    labels = []\n    skip_load = train_cache.get(feature_type.name) is not None\n    print(feature_type.name, \"skip_load is\", skip_load)\n    for fname, label in zip(df[\"fname\"], df[\"int_label\"]):\n        filename = f\"{dirname}/{fname}\"\n        labels.append(label)\n        if skip_load:\n            continue\n        waveform, sample_rate = librosa.load(filename, sr = None, res_type = 'kaiser_fast')\n        feature = ffunc(waveform, sample_rate)\n        features.append(feature)\n    \n    if not skip_load:\n        train_cache[feature_type.name] = np.array(features)\n    return train_cache[feature_type.name], np.array(labels)\n\n\ndef load_train_data_multifeature(dirname: str, feature_list: list[FeatureType], df: pd.DataFrame):\n    fl = [load_train_data(dirname, feat, df)[0] for feat in feature_list]\n    for x in fl:\n        print(x.shape, x.dtype)\n    features = np.concatenate(fl, axis=1)\n    labels = np.array(df[\"int_label\"])\n    return features, labels","metadata":{"execution":{"iopub.status.busy":"2024-10-20T02:19:17.726383Z","iopub.execute_input":"2024-10-20T02:19:17.726934Z","iopub.status.idle":"2024-10-20T02:19:17.743857Z","shell.execute_reply.started":"2024-10-20T02:19:17.726883Z","shell.execute_reply":"2024-10-20T02:19:17.742128Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# debug cell for cache actions\nlist(train_cache.keys())","metadata":{"execution":{"iopub.status.busy":"2024-10-20T02:19:54.923031Z","iopub.execute_input":"2024-10-20T02:19:54.923537Z","iopub.status.idle":"2024-10-20T02:19:54.931359Z","shell.execute_reply.started":"2024-10-20T02:19:54.923493Z","shell.execute_reply":"2024-10-20T02:19:54.930099Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Вычисление точности\n\nВ соревновании используется метрика mAP при k=3. Код для `mapk` взят с github: https://github.com/benhamner/Metrics/blob/master/Python/ml_metrics/average_precision.py . \n\nФункция `get_k_res` преобразует входной вектор вероятностей в топ `k` классов с наибольшой вероятностью. Может возвращать как числа классов, так и их строковое представление","metadata":{}},{"cell_type":"code","source":"K = 3\n\n\ndef get_k_res(y, le=None, k=K):\n    if le is None:\n        return [\n            [i for i, _ in sorted(enumerate(p), reverse=True, key=lambda x: x[1])[:k]]\n            for p in y\n        ]\n    return [\n        \" \".join(\n            le.inverse_transform([\n                i\n                for i, _ in sorted(enumerate(p), reverse=True, key=lambda x: x[1])[:k]\n            ])\n        )\n        for p in y\n    ]\n\n# Copied from https://github.com/benhamner/Metrics/blob/master/Python/ml_metrics/average_precision.py\ndef apk(actual, predicted, k=10):\n    if len(predicted)>k:\n        predicted = predicted[:k]\n\n    score = 0.0\n    num_hits = 0.0\n\n    for i,p in enumerate(predicted):\n        if p in actual and p not in predicted[:i]:\n            num_hits += 1.0\n            score += num_hits / (i+1.0)\n\n    if not len(actual):\n        return 0.0\n\n    return score / min(len(actual), k)\n\ndef mapk(actual, predicted, k=10):\n    return np.mean([apk(a,p,k) for a,p in zip(actual, predicted)])","metadata":{"execution":{"iopub.status.busy":"2024-10-20T02:22:33.206272Z","iopub.execute_input":"2024-10-20T02:22:33.207509Z","iopub.status.idle":"2024-10-20T02:22:33.219358Z","shell.execute_reply.started":"2024-10-20T02:22:33.207454Z","shell.execute_reply":"2024-10-20T02:22:33.217969Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Запуск модели на тренировочных данных\n\nИспользуем KFold для разбития данных на обучающую и валидационную выборки, считаем среднее за 5 запусков. Итоговый результат не достаточно информативен, но показывает примерный успех/неудачу и относительные результаты между моделями. Функция `train_model` дополнительно возвращает информацию о модели и промежуточных результатах в виде строку, можно использовать для отладки моделей и определения проблемных мест/неважных признаков","metadata":{}},{"cell_type":"code","source":"from sklearn.model_selection import KFold\nfrom sklearn.metrics import average_precision_score, classification_report\n\n\nKFOLD_SPLITS = 5\n\n\ndef train_model(model_func, fdata, labels):\n    kf = KFold(n_splits=KFOLD_SPLITS, shuffle=True, random_state=666)\n    scores = []\n    str_result = \"\"\n    for i, (train_index, test_index) in enumerate(kf.split(fdata)):\n        str_result += f\"Executing fold {i}...\\n\"\n        xtrain = fdata[train_index]\n        xtest = fdata[test_index]\n        gttrain = labels[train_index]\n        gttest = labels[test_index]\n        model = model_func()\n        model.fit(xtrain, gttrain)\n        y = model.predict_proba(xtest)\n        y_k = get_k_res(y)\n        score = mapk(gttest.reshape(-1, 1), y_k, K)\n        scores.append(score)\n        str_result += classification_report(gttest, get_k_res(y, k=1))\n        # Not properly works, disable for now\n        # str_result += \"\\n\" + str(model.feature_importances_) + \"\\n\"\n    str_result += f\"{scores}\\n\"\n    return np.mean(scores), str_result\n","metadata":{"execution":{"iopub.status.busy":"2024-10-20T03:01:54.262122Z","iopub.execute_input":"2024-10-20T03:01:54.263215Z","iopub.status.idle":"2024-10-20T03:01:54.275590Z","shell.execute_reply.started":"2024-10-20T03:01:54.263157Z","shell.execute_reply":"2024-10-20T03:01:54.274080Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Общий pipeline для обучения модели и проверки её результата\n\n## `pipeline`\n\nДля каждого признака:\n* Загружает данные и извлекает признаки\n* Нормализует при помощи `StandardScaler`\n* Для каждой модели:\n  * Запускает обучение и выводит средний результат\n  \n## `pipeline_multifeature`\n\nАналогично `pipeline` за исключением того, что итерации по признакам нет (они загружаются вместе и объединяются) и нормализацию отсутсвует","metadata":{}},{"cell_type":"code","source":"from sklearn.preprocessing import StandardScaler\n\n\nSAVE_DIR = \"/kaggle/working\"\n\n\ndef pipeline(models: list[tuple[str, callable]], features_list: list[FeatureType], save_report: bool = False):\n    for feature in features_list:\n        print(\"Processing\", feature, \"...\")\n        wav_data, wav_labels = load_train_data(\"/kaggle/input/freesound-audio-tagging/audio_train\", feature, train_data)\n        wav_data_scaled = StandardScaler().fit_transform(wav_data)\n        for model_name, model_func in models:\n            print(\"Processing\", model_name, \"...\")\n            score, str_result = train_model(model_func, wav_data_scaled, wav_labels)\n            print(f\"{model_name} result is {score}\")\n            if save_report:\n                with open(f\"{SAVE_DIR}/{model_name}_{feature.name}.txt\", \"w\") as f:\n                    print(str_result, \"\\n\", score, file=f)\n\n\ndef pipeline_multifeature(models: list[tuple[str, callable]], features_list: list[FeatureType], save_report: bool = False):\n    print(\"Processing\", features_list, \"...\")\n    wav_data, wav_labels = load_train_data_multifeature(\"/kaggle/input/freesound-audio-tagging/audio_train\", features_list, train_data, )\n    wav_data_scaled = wav_data\n    for model_name, model_func in models:\n        print(\"Processing\", model_name, \"...\")\n        score, str_result = train_model(model_func, wav_data_scaled, wav_labels)\n        print(f\"{model_name} result is {score}\")\n        if save_report:\n            with open(f\"{SAVE_DIR}/{model_name}_{'_'.join(x.name for x in features_list)}.txt\", \"w\") as f:\n                print(str_result, \"\\n\", score, file=f)\n\n            ","metadata":{"execution":{"iopub.status.busy":"2024-10-20T02:37:03.319322Z","iopub.execute_input":"2024-10-20T02:37:03.320784Z","iopub.status.idle":"2024-10-20T02:37:03.334910Z","shell.execute_reply.started":"2024-10-20T02:37:03.320690Z","shell.execute_reply":"2024-10-20T02:37:03.333422Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Определяем модели и признаки","metadata":{}},{"cell_type":"code","source":"from catboost import CatBoostClassifier\nfrom sklearn.svm import SVC\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.ensemble import RandomForestClassifier\nfrom xgboost import XGBClassifier\n\n\ndef get_catboost() -> SVC:\n    return CatBoostClassifier(\n        verbose=False, task_type='GPU'\n    )\n\n\ndef get_svc() -> SVC:\n    return SVC(\n        C=10, gamma='auto', kernel='rbf', random_state=69, probability=True,\n    )\n\n\ndef get_kns() -> KNeighborsClassifier:\n    return KNeighborsClassifier(\n        n_neighbors = 5, weights = 'distance', algorithm = 'brute',\n        leaf_size = 30, n_jobs=4\n    )\n\n\ndef get_dts() -> DecisionTreeClassifier:\n    return DecisionTreeClassifier()\n\n\ndef get_rfs() -> RandomForestClassifier:\n    return RandomForestClassifier(\n        n_estimators=1000,\n    )\n\n\ndef get_xgboost() -> XGBClassifier:\n    return XGBClassifier(\n        max_depth=5, learning_rate=0.05,\n        n_estimators=3000, reg_alpha=0.2, \n        colsample_bylevel=0.9, colsample_bytree=0.9\n    )\n\n\nmodel_list = [\n    (\"SVC\", get_svc),\n    (\"KNeighborsClassifier\", get_kns),\n    (\"DecisionTreeClassifier\", get_dts),\n    (\"RandomForestClassifier\", get_rfs),\n    (\"XGBClassifier\", get_xgboost),\n]\nfeature_list = [\n    FeatureType.MFCC,\n    FeatureType.MFCC_STAT,\n    FeatureType.ZeroCrossingRate,\n    FeatureType.SpectralRolloff,\n    FeatureType.SpectralCentroid,\n    FeatureType.Chromogram,\n    FeatureType.MelSpectrogram,\n]","metadata":{"execution":{"iopub.status.busy":"2024-10-20T03:04:20.816795Z","iopub.execute_input":"2024-10-20T03:04:20.817354Z","iopub.status.idle":"2024-10-20T03:04:20.832608Z","shell.execute_reply.started":"2024-10-20T03:04:20.817302Z","shell.execute_reply":"2024-10-20T03:04:20.830912Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Запускаем по отдельным признакам\n#pipeline(model_list, feature_list)","metadata":{"execution":{"iopub.status.busy":"2024-10-20T03:04:26.011655Z","iopub.execute_input":"2024-10-20T03:04:26.012222Z","iopub.status.idle":"2024-10-20T03:26:46.907307Z","shell.execute_reply.started":"2024-10-20T03:04:26.012174Z","shell.execute_reply":"2024-10-20T03:26:46.905248Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Запускаем по совокупности признаков\n#pipeline_multifeature(model_list, feature_list)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Делаем кэш для тестовых данных аналогично кэшу для обучающих\ntest_cache = {}","metadata":{"execution":{"iopub.status.busy":"2024-10-20T03:26:54.143029Z","iopub.execute_input":"2024-10-20T03:26:54.143524Z","iopub.status.idle":"2024-10-20T03:26:54.149182Z","shell.execute_reply.started":"2024-10-20T03:26:54.143476Z","shell.execute_reply":"2024-10-20T03:26:54.147811Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# Создание итогового файлика с разметкой\n\n## Загрузка данных\n\nФункции `load_test_data` и `load_test_data_multifeature` аналогичны функциям для обучающей выборки\n\n## Предсказание разметки\n\nФункция `make_submission` загружает обучающие и тестовые данные, затем проводит обучение и предсказание. Формируется csv файлик с 3 метками для каждого аудиофайла","metadata":{}},{"cell_type":"code","source":"import os\n\n\ndef load_test_data(dirname: str, feature_type: FeatureType):\n    ffunc = TYPE_TO_FUNC[feature_type]\n    features = []\n    fnames = []\n    skip_load = test_cache.get(feature_type.name) is not None\n    for fname in os.listdir(dirname):\n        if not fname.endswith(\".wav\"):\n            continue\n        filename = f\"{dirname}/{fname}\"\n        fnames.append(fname)\n        if skip_load:\n            continue\n        waveform, sample_rate = librosa.load(filename, sr = None, res_type = 'kaiser_fast')\n        feature = ffunc(waveform, sample_rate)\n        features.append(feature)\n    \n    if not skip_load:\n        test_cache[feature_type.name] = np.array(features)\n    return test_cache[feature_type.name], fnames\n\n\ndef load_test_data_multifeature(dirname: str, feature_list: list[FeatureType]):\n    fl = [load_test_data(dirname, feat)[0] for feat in feature_list]\n    features = np.concatenate(fl, axis=1)\n    fnames = load_test_data(dirname, feature_list[0])[1]\n    return features, fnames\n\n\ndef make_submission(model_func: callable, feature_type: FeatureType, filename: str, use_multifeature: bool = False):\n    # Load test data\n    if use_multifeature:\n        wav_data_test, fnames = load_test_data_multifeature(\"/kaggle/input/freesound-audio-tagging/audio_test\", feature_type)\n        wav_data_scaled_test = wav_data_test\n    else:\n        wav_data_test, fnames = load_test_data(\"/kaggle/input/freesound-audio-tagging/audio_test\", feature_type)\n        wav_data_scaled_test = StandardScaler().fit_transform(wav_data_test)\n    # Load train data\n    train_data = pd.read_csv(\"/kaggle/input/freesound-audio-tagging/train_post_competition.csv\")\n    le = preprocessing.LabelEncoder()\n    train_data[\"int_label\"] = le.fit_transform(train_data[\"label\"])\n    if use_multifeature:\n        wav_data, wav_labels = load_train_data_multifeature(\"/kaggle/input/freesound-audio-tagging/audio_train\", feature_type, train_data)\n        wav_data_scaled = wav_data\n    else:\n        wav_data, wav_labels = load_train_data(\"/kaggle/input/freesound-audio-tagging/audio_train\", feature_type, train_data)\n        wav_data_scaled = StandardScaler().fit_transform(wav_data)\n    model = model_func()\n    model.fit(wav_data_scaled, wav_labels)\n    y = model.predict_proba(wav_data_scaled_test)\n    res_y = get_k_res(y, le)\n    res = pd.DataFrame({\"fname\": fnames, \"label\": res_y})\n    res.to_csv(f\"/kaggle/working/{filename}.csv\", index=False)","metadata":{"execution":{"iopub.status.busy":"2024-10-20T04:15:45.791155Z","iopub.execute_input":"2024-10-20T04:15:45.791824Z","iopub.status.idle":"2024-10-20T04:15:45.814146Z","shell.execute_reply.started":"2024-10-20T04:15:45.791755Z","shell.execute_reply":"2024-10-20T04:15:45.812219Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"# Размечаем тестовые данные\nmake_submission(get_xgboost, [FeatureType.MFCC, FeatureType.MFCC_STAT, FeatureType.ZeroCrossingRate, FeatureType.SpectralRolloff, FeatureType.SpectralCentroid, FeatureType.Chromogram, FeatureType.ChromogramStat, FeatureType.MelSpectrogram], \"submission\", True)","metadata":{"execution":{"iopub.status.busy":"2024-10-20T05:20:19.632240Z","iopub.execute_input":"2024-10-20T05:20:19.632831Z","iopub.status.idle":"2024-10-20T05:34:04.122479Z","shell.execute_reply.started":"2024-10-20T05:20:19.632779Z","shell.execute_reply":"2024-10-20T05:34:04.120370Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# ","metadata":{}}]}