code/data_description_plots_2021_2022.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "4f3b2a44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The autoreload extension is already loaded. To reload it, use:\n",
      "  %reload_ext autoreload\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import sys\n",
    "import datetime\n",
    "from time import gmtime\n",
    "from time import strftime\n",
    "from pathlib import Path\n",
    "from datetime import timedelta  \n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import pandas as pd\n",
    "from scipy import signal\n",
    "import pickle\n",
    "import librosa\n",
    "import librosa.display\n",
    "from feature_extraction import data_ls_to_string\n",
    "\n",
    "from spectral_subtraction import spectral_subtraction\n",
    "\n",
    "if not sys.warnoptions:\n",
    "    import warnings\n",
    "    warnings.simplefilter(\"ignore\")\n",
    "\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4076459",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import zipfile\n",
    "from zipfile import ZIP_LZMA\n",
    "from zipfile import ZIP_DEFLATED\n",
    "\n",
    "def zip_wav_files(input_dir, output_dir):\n",
    "    # Create the output directory if it doesn't exist\n",
    "    if not os.path.exists(output_dir):\n",
    "        os.makedirs(output_dir)\n",
    "\n",
    "    # Loop through all files in the input directory\n",
    "    for filename in os.listdir(input_dir):\n",
    "\n",
    "        if filename.lower().endswith(\".wav\"):\n",
    "            # Define the full file paths\n",
    "            file_path = os.path.join(input_dir, filename)\n",
    "            zip_file_path = os.path.join(output_dir, f\"{os.path.splitext(filename)[0]}.zip\")\n",
    "\n",
    "            # Check if the zip file already exists\n",
    "            if os.path.exists(zip_file_path):\n",
    "                print(f\"Skipping {filename}, already zipped.\")\n",
    "                continue\n",
    "\n",
    "            # Create a zip file and add the wav file to it using ZIP_LZMA for maximum compression\n",
    "            #with zipfile.ZipFile(zip_file_path, mode='x', compression=ZIP_LZMA) as zip_file:\n",
    "            with zipfile.ZipFile(zip_file_path, mode='x', compression=ZIP_DEFLATED, compresslevel=9,\n",
    "                                 strict_timestamps=False) as zip_file:\n",
    "                zip_file.write(file_path, arcname=filename)\n",
    "\n",
    "            print(f\"Zipped {filename} to {zip_file_path}\")\n",
    "\n",
    "# Define the input and output directories\n",
    "input_directory = '../data/Nectar/full_2021'\n",
    "output_directory = '../data/Nectar/full_2021_zipped'\n",
    "\n",
    "# Zip the wav files\n",
    "zip_wav_files(input_directory, output_directory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e59aeac8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import shutil\n",
    "\n",
    "def move_hive_0_files(source_dir, target_dir):\n",
    "    # Create the target directory if it does not exist\n",
    "    if not os.path.exists(target_dir):\n",
    "        os.makedirs(target_dir)\n",
    "    \n",
    "    # Iterate over all files in the source directory\n",
    "    for filename in os.listdir(source_dir):\n",
    "        if \"HIVE-0\" in filename:\n",
    "            # Construct full file path\n",
    "            file_path = os.path.join(source_dir, filename)\n",
    "            # Move the file to the target directory\n",
    "            shutil.move(file_path, target_dir)\n",
    "            print(f\"Moved: {filename}\")\n",
    "\n",
    "# Define your source and target directories\n",
    "source_directory = '../data/Nectar/full_2022'\n",
    "target_directory = '../data/Nectar/empty_2022'\n",
    "\n",
    "# Call the function to move files\n",
    "move_hive_0_files(source_directory, target_directory)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bc12d338",
   "metadata": {},
   "outputs": [],
   "source": [
    "folder_path = \"../data/Nectar/full_2021\"\n",
    "\n",
    "# Initialize total size\n",
    "total_size = 0\n",
    "num = 0\n",
    "\n",
    "# Loop through files in the folder\n",
    "for filename in os.listdir(folder_path):\n",
    "    # Check if the file is a WAV file and has tag == 0\n",
    "    filename = filename[:-4] + \".wav\"\n",
    "    if filename.endswith(\".wav\") and filename.split(\"_\")[2].split(\"-\")[1] != \"0.wav\":\n",
    "        # Extract date from the filename\n",
    "        date_str = filename.split(\"_\")[0]\n",
    "        time_str = filename.split(\"_\")[1]\n",
    "        datetime_str = date_str + \"_\" + time_str\n",
    "        \n",
    "        datetime_obj = datetime.datetime.strptime(datetime_str, \"%d-%m-%Y_%Hh%M\")\n",
    "\n",
    "        \n",
    "        if datetime_obj >= datetime.datetime(2021,1, 1) and datetime_obj <= datetime.datetime(2021, 12, 31):\n",
    "        #if datetime_obj >= datetime.datetime(2021,6, 22) and datetime_obj <= datetime.datetime(2021, 10, 19):\n",
    "            # Get the file size\n",
    "            # Get the file size\n",
    "            file_size = os.path.getsize(os.path.join(folder_path, filename))\n",
    "            # Add to total size\n",
    "            total_size += file_size\n",
    "            num += 1\n",
    "            \n",
    "total_size_gb = total_size / (1024 ** 3)\n",
    "total_size_zipped_gb = (num*18) / (1024 ** 1)\n",
    "\n",
    "\n",
    "# Print the total size\n",
    "print(\"Total size of files:\", total_size_gb, \"GB\")\n",
    "print(\"Total size of zipped files:\", total_size_zipped_gb, \"GB\")\n",
    "\n",
    "print(\"Total number of files:\", num )\n",
    "\n",
    "total_time = num*15\n",
    "\n",
    "h=total_time//60\n",
    "m=total_time%60\n",
    "print(\"Hours=\",h)\n",
    "print(\"Minutes=\",m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "772a6dac",
   "metadata": {},
   "outputs": [],
   "source": [
    "folder_path = \"../data/Nectar/full_2022\"\n",
    "\n",
    "# Initialize total size\n",
    "total_size = 0\n",
    "num = 0\n",
    "\n",
    "\n",
    "# Loop through files in the folder\n",
    "for filename in os.listdir(folder_path):\n",
    "    # Check if the file is a WAV file and has tag == 0\n",
    "    filename = filename[:-4] + \".wav\"\n",
    "    if filename.endswith(\".wav\") and filename.split(\"_\")[2].split(\"-\")[1] != \"0.wav\":\n",
    "        # Extract date from the filename\n",
    "        date_str = filename.split(\"_\")[0]\n",
    "        time_str = filename.split(\"_\")[1]\n",
    "        datetime_str = date_str + \"_\" + time_str\n",
    "        datetime_obj = datetime.datetime.strptime(datetime_str, \"%d-%m-%Y_%Hh%M\")\n",
    "        # Check if the date is between June and August 2021\n",
    "        if datetime_obj >= datetime.datetime(2022,1, 1) and datetime_obj <= datetime.datetime(2022, 12,31):\n",
    "        #if datetime_obj >= datetime.datetime(2022,7, 11) and datetime_obj <= datetime.datetime(2022, 9, 7):\n",
    "            # Get the file size\n",
    "            file_size = os.path.getsize(os.path.join(folder_path, filename))\n",
    "            # Add to total size\n",
    "            total_size += file_size\n",
    "            num += 1\n",
    "            \n",
    "total_size_gb = total_size / (1024 ** 3)\n",
    "total_size_zipped_gb = (num*18) / (1024 ** 1)\n",
    "\n",
    "\n",
    "# Print the total size\n",
    "print(\"Total size of files:\", total_size_gb, \"GB\")\n",
    "print(\"Total size of zipped files:\", total_size_zipped_gb, \"GB\")\n",
    "\n",
    "print(\"Total number of files:\", num )\n",
    "\n",
    "total_time = num*15\n",
    "\n",
    "h=total_time//60\n",
    "m=total_time%60\n",
    "print(\"Hours=\",h)\n",
    "print(\"Minutes=\",m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1700a6cc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "5bb52ae5",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "\n",
    "# 2021 data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "95e627b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"../data/annotations/inspections_2021.csv\")\n",
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e08e418",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dead hives : 3640, 3629\n",
    "#after winter: 3627, 3628, 3629, 3692"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d2136a3",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "plt.rc('legend',fontsize=14) # using a size in points\n",
    "plt.rcParams['xtick.labelsize'] = 20 \n",
    "plt.rcParams['ytick.labelsize'] = 20 \n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,12), sharex=True)\n",
    "sns.histplot(data[\"Fob 1st\"]+data[\"Fob 2nd\"]+data[\"Fob 3rd\"], bins = np.arange(20,32)-0.5, color='steelblue')\n",
    "plt.xticks(np.arange(20,31));\n",
    "plt.xlabel('Frames of bee', size = 22)\n",
    "plt.ylabel('Count', size = 22)\n",
    "plt.savefig('fob_2021.png', dpi=400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84af0331",
   "metadata": {},
   "outputs": [],
   "source": [
    "notes_and_opening = data[['Date', 'Tag number', 'Open', 'Close', 'Notes']]\n",
    "notes_and_opening.dropna(subset = ['Date', 'Open'], inplace=True)\n",
    "notes_and_opening['Date'] = pd.to_datetime(notes_and_opening['Date'], dayfirst=True)\n",
    "notes_and_opening.reset_index(inplace=True)\n",
    "notes_and_opening.info()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7adbe890",
   "metadata": {},
   "outputs": [],
   "source": [
    "        \n",
    "notes_and_opening['Open'] = pd.to_datetime(notes_and_opening['Open'], dayfirst=True)\n",
    "notes_and_opening['Close'] = pd.to_datetime(notes_and_opening['Close'], dayfirst=True)\n",
    "\n",
    "for i in range(len(notes_and_opening)):\n",
    "    if not pd.isna(notes_and_opening.Close[i]):\n",
    "        notes_and_opening['Close'][i] = datetime.datetime.combine(notes_and_opening.Date[i], notes_and_opening.Close[i])\n",
    "        #notes_and_opening['Close'] = pd.to_datetime(notes_and_opening['Close'], dayfirst=True)\n",
    "        \n",
    "for i in range(len(notes_and_opening)):\n",
    "    if not pd.isna(notes_and_opening.Open[i]):\n",
    "        notes_and_opening['Open'][i] = datetime.datetime.combine(notes_and_opening.Date[i], notes_and_opening.Open[i])\n",
    "        #notes_and_opening['Close'] = pd.to_datetime(notes_and_opening['Close'], dayfirst=True)\n",
    "        \n",
    "\n",
    "notes_and_opening.drop('index', inplace=True, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e84df7bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = data.fillna(0)\n",
    "data['Date'] = pd.to_datetime(data['Date']).dt.strftime(\"%Y-%m-%d\")\n",
    "#Enotes_and_opening['Tag'] = notes_and_opening['Tag'].apply(lambda x: str(x).replace(u'\\xa0', u'')).astype('int')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74547c27",
   "metadata": {},
   "outputs": [],
   "source": [
    "data['fob'] = data[\"Fob 1st\"] + data[\"Fob 2nd\"]+ data[\"Fob 3rd\"]\n",
    "data= data.set_index(data['Date'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1590d9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rc('legend',fontsize=10) # using a size in points\n",
    "plt.rcParams['xtick.labelsize'] = 20 \n",
    "plt.rcParams['ytick.labelsize'] = 20 \n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,6), sharex=True)\n",
    "\n",
    "sns.barplot(data, x=data.index, y='fob', hue=\"Tag number\")\n",
    "plt.setp(ax.get_legend().get_title(), fontsize='12') # for legend title\n",
    "ax.legend(loc='upper left',ncol=2, title=\"Hive ID\")\n",
    "\n",
    "plt.xticks(rotation=45)\n",
    "plt.ylabel('Frames of bee', size = 22)\n",
    "plt.xlabel('Date', size = 22)\n",
    "plt.tight_layout()\n",
    "plt.savefig('fob_detailed_2021.png', dpi=400)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a8956a3",
   "metadata": {},
   "outputs": [],
   "source": [
    "unique_hives = data['Tag number'].unique()\n",
    "unique_hives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a04b76f",
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped = data.groupby(['Tag number'])\n",
    "dict_hives = {}\n",
    "for i in unique_hives:\n",
    "        dict_hives[i] = grouped.get_group(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "69c148d4",
   "metadata": {},
   "outputs": [],
   "source": [
    "for hive in  data['Tag number'].unique():\n",
    "    dict_hives[hive] = dict_hives[hive].set_index(dict_hives[hive]['Date'])\n",
    "    idx = pd.date_range(dict_hives[hive].index.min(), dict_hives[hive].index.max()+ timedelta(days=1), freq=\"15min\")#  + timedelta(days=12)\n",
    "    dict_hives[hive] = dict_hives[hive].reindex(idx)\n",
    "    dict_hives[hive] = dict_hives[hive].drop(['Date'], axis=1)\n",
    "    dict_hives[hive] = dict_hives[hive].interpolate(method=\"linear\")#interpolate(method=\"ffill\")\n",
    "    dict_hives[hive][\"fob\"] = dict_hives[hive][\"Fob 1st\"] + dict_hives[hive][\"Fob 2nd\"]+ dict_hives[hive][\"Fob 3rd\"]\n",
    "    dict_hives[hive][\"fob\"] = dict_hives[hive][\"fob\"].round(0).astype('f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a0f7c3c",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_hives[3631]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19c68ba5",
   "metadata": {},
   "source": [
    "# read csv file 2022"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "19930037",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_2022 = pd.read_csv(\"../data/annotations/inspections_2022.csv\")\n",
    "data_2022['Date'] = pd.to_datetime(data_2022['Date'], dayfirst=True).dt.date\n",
    "data_2022 = data_2022.set_index('Date')\n",
    "data_2022['Tag number'] = data_2022['Tag number'].astype('int')\n",
    "\n",
    "data_2022"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9718226f",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0a276324",
   "metadata": {},
   "source": [
    "# Varroa measurement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25b45497",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_varroa = data_2022[data_2022['Category'] == 'varroa'][['Action detail', 'Tag number']]\n",
    "df_varroa['Action detail'] = df_varroa['Action detail'].astype('f')\n",
    "df_varroa['Tag number'] = df_varroa['Tag number'] .astype('int')\n",
    "\n",
    "df_varroa.index = pd.to_datetime(df_varroa.index, dayfirst=True)\n",
    "df_varroa['date'] = df_varroa.index\n",
    "df_varroa['date'] = df_varroa['date'].dt.date"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33adcead",
   "metadata": {},
   "outputs": [],
   "source": [
    "#df_varroa_temp\n",
    "plt.rc('legend',fontsize=16) # using a size in points\n",
    "plt.rcParams['xtick.labelsize'] = 16 \n",
    "plt.rcParams['ytick.labelsize'] = 16 \n",
    "\n",
    "\n",
    "for d in df_varroa.index.unique():\n",
    "    \n",
    "    df_varroa_temp = df_varroa.loc[d]\n",
    "\n",
    "    df_varroa_temp = df_varroa_temp.sort_values('Tag number')\n",
    "    fig, ax = plt.subplots(figsize=(12, 10))\n",
    "\n",
    "    ax = sns.barplot(df_varroa_temp.sort_values('Tag number'), x=\"Tag number\", y='Action detail', color='steelblue')\n",
    "\n",
    "    for i, p in enumerate(ax.patches):\n",
    "        ax.text(p.get_x() + p.get_width() / 2., p.get_height(), df_varroa_temp['Action detail'][i],\n",
    "                ha='center', va='bottom', color='black', fontsize=16, weight='bold');\n",
    "\n",
    "    plt.xlabel('Hive ID', size = 18)\n",
    "    plt.ylabel('Varroa infestation', size = 18)\n",
    "    #plt.title('Varroa infestation measurement on ' + str(d)[:10] , weight = 'bold')\n",
    "    #plt.savefig('varroa' +  str(d)   + '.png', dpi=400) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0c491e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "# dead hives : 3628, 3629, 3631\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afa71fa5",
   "metadata": {},
   "source": [
    "# Frames of bees"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e86e3d8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_2022 = data_2022[data_2022['Category'] == 'frames of bees']\n",
    "data_2022['Action detail'] = pd.to_numeric(data_2022['Action detail']) # conver the column from object to float\n",
    "data_2022['Action detail'] = data_2022['Action detail'].astype('f') # covert from float to int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80936af8",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_2022[\"fob\"] = data_2022[\"Action detail\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24ff7757",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rc('legend',fontsize=10) # using a size in points\n",
    "plt.rcParams['xtick.labelsize'] = 20 \n",
    "plt.rcParams['ytick.labelsize'] = 20 \n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,6), sharex=True)\n",
    "\n",
    "sns.barplot(data_2022, x=data_2022.index, y='fob', hue=\"Tag number\")\n",
    "plt.setp(ax.get_legend().get_title(), fontsize='12') # for legend title\n",
    "ax.legend(loc='upper right',ncol=2, title=\"Hive ID\")\n",
    "\n",
    "plt.xticks(rotation=45)\n",
    "plt.ylabel('Frames of bee', size = 22)\n",
    "plt.xlabel('Date', size = 22)\n",
    "plt.tight_layout()\n",
    "plt.savefig('fob_detailed_2022.png', dpi=400)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e00d6a32",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rc('legend',fontsize=14) # using a size in points\n",
    "plt.rcParams['xtick.labelsize'] = 20 \n",
    "plt.rcParams['ytick.labelsize'] = 20 \n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,12), sharex=True)\n",
    "sns.histplot(data_2022[\"fob\"] , bins = np.arange(1,22)-0.5, color='steelblue')\n",
    "plt.xticks(np.arange(1,21));\n",
    "plt.xlabel('Frames of bee', size = 22)\n",
    "plt.ylabel('Count', size = 22)\n",
    "\n",
    "plt.savefig('fob_2022.png', dpi=400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f18d050b",
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped = data_2022.groupby(['Tag number'])\n",
    "dict_hives_2022 = {}\n",
    "for i in data_2022['Tag number'].unique():\n",
    "        dict_hives_2022[i] = grouped.get_group(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "21f7a061",
   "metadata": {},
   "outputs": [],
   "source": [
    "for hive in  data_2022['Tag number'].unique():\n",
    "    idx = pd.date_range(dict_hives_2022[hive].index.min(), dict_hives_2022[hive].index.max(), freq=\"15min\")\n",
    "    dict_hives_2022[hive] = dict_hives_2022[hive].reindex(idx)\n",
    "    dict_hives_2022[hive] = dict_hives_2022[hive].interpolate(method=\"linear\")#interpolate(method=\"ffill\")\n",
    "    dict_hives_2022[hive]['fob'] = dict_hives_2022[hive]['fob'].round(0).astype('f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6dbe41e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_hives_2022[3631]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d5dc3c07",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "71141892",
   "metadata": {},
   "source": [
    "# Temperature and humidiity "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f18664ac",
   "metadata": {},
   "outputs": [],
   "source": [
    "full_sensor_df= pd.read_csv(\"../data/temperature_humidity/sensor_2021.csv\")\n",
    "full_sensor_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4f9922a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "grouped = full_sensor_df.groupby(['Tag number'])\n",
    "sensors_hives = {}\n",
    "for i in full_sensor_df['Tag number'].unique():\n",
    "        sensors_hives[i] = grouped.get_group(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0b05ea4",
   "metadata": {},
   "outputs": [],
   "source": [
    "for hive in  full_sensor_df['Tag number'].unique():\n",
    "    sensors_hives[hive]['Date'] = pd.to_datetime(sensors_hives[hive]['Date'])\n",
    "\n",
    "    sensors_hives[hive] = sensors_hives[hive].set_index(sensors_hives[hive]['Date'])\n",
    "    sensors_hives[hive] = sensors_hives[hive].drop(['Date'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75fb97c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "resampled_sensor_hive = {}\n",
    "x = {}\n",
    "for hive in full_sensor_df['Tag number'].unique():\n",
    "    x[hive] = sensors_hives[hive].resample('h').mean()\n",
    "    idx = pd.date_range(x[hive].index.min(), x[hive].index.max() + timedelta(days=1) - \n",
    "                        pd.to_timedelta(x[hive].index.max().hour, unit='h')\n",
    "                        - pd.to_timedelta(1, unit='h'), freq='H')\n",
    "    x[hive] = x[hive].reindex(idx).interpolate(method=\"linear\") #interpolate(method=\"spline\", order=2, limit = 100, limit_direction='both')\n",
    "    #x[hive] = x[hive].dropna(subset=['audio_density'])\n",
    "    if len(x[hive]) > 0:\n",
    "        resampled_sensor_hive[hive] = x[hive]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4c5d5fd",
   "metadata": {},
   "source": [
    "# Weather info"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7c6c01a",
   "metadata": {},
   "outputs": [],
   "source": [
    "env = pd.read_csv(\"../data/weather_info/weather_2021_2022.csv\")\n",
    "env['Date/Time (LST)'] = pd.to_datetime(env['Date/Time (LST)'])\n",
    "\n",
    "env = env.set_index(env['Date/Time (LST)'])\n",
    "env = env.interpolate(method=\"ffill\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "620e3a00",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = full_sensor_df\n",
    "\n",
    "df['Date'] = pd.to_datetime(df['Date'])\n",
    "df = df.set_index(df['Date'])\n",
    "df = df.drop(['Date'], axis=1)\n",
    "#df = df.interpolate(method=\"ffill\")\n",
    "df = df.resample('h').mean()\n",
    "\n",
    "df = df.groupby(df.index).mean()\n",
    "idx = pd.date_range(df.index.min(), df.index.max() + timedelta(days=1) - \n",
    "                    pd.to_timedelta(df.index.max().hour, unit='h')\n",
    "                    - pd.to_timedelta(1, unit='h'), freq='H')\n",
    "df = df.reindex(idx).interpolate(method=\"linear\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a65419f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rc('legend',fontsize=18) # using a size in points\n",
    "plt.rcParams['xtick.labelsize'] = 14\n",
    "plt.rcParams['ytick.labelsize'] = 14 \n",
    "\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,10))\n",
    "\n",
    "\n",
    "plt.subplot(2, 1,1)\n",
    "plt.plot(df['temperature'].loc['2021-06-15':'2021-10-30'].resample('d').mean(), color='red', linestyle='dashed',\n",
    "linewidth=4, markersize=12, label = \"Internal\")\n",
    "plt.plot(env['Temp (°C)'].loc['2021-06-15':'2021-10-30'].resample('d').mean(), color='orange', linestyle='dashed',\n",
    "linewidth=4, markersize=12, label = \"External\")\n",
    "\n",
    "\n",
    "#plt.xticks(sensors_hives[hive_id.hive_identity[hive]].loc[pd.to_datetime(date):pd.to_datetime(date)+ timedelta(days=1), 'temperature'].resample('30min').mean().index[0:48:4], idx_12.strftime('%H:%M'))\n",
    "#plt.xlim([sensors_hives[hive_id.hive_identity[hive]].loc[pd.to_datetime(date):pd.to_datetime(date)+ timedelta(days=1), 'temperature'].resample('30min').mean().index.min(), sensors_hives[hive_id.hive_identity[hive]].loc['2021-8-12 00:00':'2021-8-13 00:00', 'temperature'].resample('15min').mean().index.max()])\n",
    "plt.ylabel('Temperature ($^\\circ$C)', size=24)\n",
    "plt.legend()\n",
    "\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(df['humidity'].loc['2021-06-15':'2021-10-30'].resample('d').mean(), color='blue', linestyle='dashed',\n",
    "linewidth=4, markersize=12, label = \"Internal \")\n",
    "plt.plot(env['Rel Hum (%)'].loc['2021-06-15':'2021-10-30'].resample('d').mean(), color='green', linestyle='dashed',\n",
    "linewidth=4, markersize=12, label = \"External\")\n",
    "\n",
    "\n",
    "\n",
    "#plt.xticks(sensors_hives[hive_id.hive_identity[hive]].loc[pd.to_datetime(date):pd.to_datetime(date)+ timedelta(days=1), 'humidity'].resample('30min').mean().index[0:48:4], idx_12.strftime('%H:%M'))\n",
    "#plt.xlim([sensors_hives[hive_id.hive_identity[hive]].loc[pd.to_datetime(date):pd.to_datetime(date)+ timedelta(days=1), 'humidity'].resample('30min').mean().index.min(), sensors_hives[hive_id.hive_identity[hive]].loc['2021-8-12 00:00':'2021-8-13 00:00', 'temperature'].resample('15min').mean().index.max()])\n",
    "plt.ylabel('Humidity (%)', size=24)\n",
    "plt.xlabel('Time', size=24)\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('temp_humid_total_2021.png')\n",
    "#plt.close('all')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9e9707fe",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00083f81",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "04981a57",
   "metadata": {},
   "source": [
    "# Synchronizing empty and beehive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5cf630ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "date = '2021-08-16'\n",
    "hive = 3691\n",
    "\n",
    "idx = pd.date_range(date, periods=96, freq=\"15min\")\n",
    "df_time = pd.DataFrame(data=np.array(np.zeros(96)), index = idx, columns=['Tag'], dtype=None, copy=None)\n",
    "df_time[\"Tag\"] = df_time[\"Tag\"].astype('int')\n",
    "\n",
    "file_names_empty = data_index_to_string(df_time)\n",
    "file_names_bee = data_index_to_string(dict_hives[hive].loc[date])\n",
    "\n",
    "ls_dates = []\n",
    "empty = np.array(1)\n",
    "bee = np.array(1)\n",
    "\n",
    "for file in range(len(file_names_bee)):\n",
    "    try:\n",
    "        signal_bee, sample_rate = librosa.load(os.path.join('../data/Nectar/full/', file_names_bee[file]), sr=2048)\n",
    "        print(file_names_bee[file])\n",
    "        signal_empty, sample_rate = librosa.load(os.path.join('../data/Nectar/full/', file_names_empty[file]), sr=2048)\n",
    "        print(file_names_empty[file])\n",
    "        bee = np.concatenate((bee, signal_bee[:min(signal_bee.shape[0], signal_empty.shape[0])]), axis=None)\n",
    "        ls_dates.append(dict_hives[hive].loc[date].index[file])\n",
    "        print(bee.shape)\n",
    "        \n",
    "        empty = np.concatenate((empty, signal_empty[:min(signal_bee.shape[0], signal_empty.shape[0])]), axis=None)\n",
    "        print(empty.shape)\n",
    "        \n",
    "    except OSError as e:\n",
    "            pass#print('The file is not present.') \n",
    "        \n",
    "np.save(str(hive) + '_' + str(date) + '_12h.npy', bee)\n",
    "np.save(str(0) + '_' + str(hive) + '_' + str(date) + '_12h.npy', empty)\n",
    "np.save(str(hive) + '_' + str(date) + '_times.npy', ls_dates)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03dfbcb3",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rc('legend',fontsize=18) # using a size in points\n",
    "plt.rcParams['xtick.labelsize'] = 14\n",
    "plt.rcParams['ytick.labelsize'] = 14 \n",
    "\n",
    "\n",
    "\n",
    "date = '2021-08-12'\n",
    "hive = 3631\n",
    "\n",
    "bee_12h = np.load(str(hive) + '_' + str(date) + '_12h.npy')\n",
    "\n",
    "empty_hive_12h = np.load(str(0) + '_' + str(hive) + '_' + str(date) + '_12h.npy')\n",
    "\n",
    "ls_dates  = np.load(str(hive) + '_' + str(date) + '_times.npy', allow_pickle=True)\n",
    "idx_12 = pd.date_range(ls_dates[0], periods=12, freq=\"2H\")\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(16,10))\n",
    "\n",
    "\n",
    "plt.subplot(2, 1,1)\n",
    "plt.plot(sensors_hives[hive].loc[pd.to_datetime(date):pd.to_datetime(date)+ timedelta(days=1),\n",
    "                                 'temperature'].resample('30min').mean().interpolate(method=\"linear\"), color='red', linestyle='dashed',\n",
    "     linewidth=4, markersize=12, label = \"Internal\")\n",
    "plt.plot(env['Temp (°C)'][date], color='orange', linestyle='dashed',\n",
    "     linewidth=4, markersize=12, label = \"External\")\n",
    "\n",
    "\n",
    "plt.xticks(sensors_hives[hive].loc[pd.to_datetime(date):pd.to_datetime(date)+ timedelta(days=1), 'temperature'].resample('30min').mean().index[0:48:4], idx_12.strftime('%H:%M'))\n",
    "plt.xlim([sensors_hives[hive].loc[pd.to_datetime(date):pd.to_datetime(date)+ timedelta(days=1), 'temperature'].resample('30min').mean().index.min(), \n",
    "          sensors_hives[hive].loc['2021-8-12 00:00':'2021-8-13 00:00', 'temperature'].resample('15min').mean().index.max()])\n",
    "plt.ylabel('Temperature ($^\\circ$C)', size=24)\n",
    "plt.legend()\n",
    "\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(sensors_hives[hive].loc[pd.to_datetime(date):pd.to_datetime(date)+ timedelta(days=1), 'humidity'].resample('30min').mean().interpolate(method=\"linear\"), color='blue', linestyle='dashed',\n",
    "     linewidth=4, markersize=12, label = \"Internal \")\n",
    "plt.plot(env['Rel Hum (%)'][date], color='green', linestyle='dashed',\n",
    "     linewidth=4, markersize=12, label = \"External\")\n",
    "\n",
    "plt.xticks(sensors_hives[hive].loc[pd.to_datetime(date):pd.to_datetime(date)+ timedelta(days=1), 'humidity'].resample('30min').mean().index[0:48:4], idx_12.strftime('%H:%M'))\n",
    "plt.xlim([sensors_hives[hive].loc[pd.to_datetime(date):pd.to_datetime(date)+ timedelta(days=1), 'humidity'].resample('30min').mean().index.min(),\n",
    "          sensors_hives[hive].loc['2021-8-12 00:00':'2021-8-13 00:00', 'temperature'].resample('15min').mean().index.max()])\n",
    "plt.ylabel('Humidity (%)', size=24)\n",
    "plt.xlabel('Time', size=24)\n",
    "\n",
    "plt.legend()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('paper_temp_humid_12h_'+ str(hive) + '_' + str(date) +'.png')\n",
    "#plt.close('all')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c54568b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rcParams['agg.path.chunksize'] = 10000\n",
    "\n",
    "plt.rc('legend',fontsize=16) # using a size in points\n",
    "plt.rcParams['xtick.labelsize'] = 14 \n",
    "plt.rcParams['ytick.labelsize'] = 14 \n",
    "\n",
    "date = '2021-08-16'\n",
    "hive = 3691\n",
    "\n",
    "bee_12h = np.load(str(hive) + '_' + str(date) + '_12h.npy')\n",
    "ls_dates  = np.load(str(hive) + '_' + str(date) + '_times.npy', allow_pickle=True)\n",
    "\n",
    "rolling = 1000\n",
    "\n",
    "rms=librosa.feature.rms(y=bee_12h, S=None, frame_length=2048, hop_length=512, center=True, pad_mode='constant')\n",
    "\n",
    "ma_rms = pd.Series(rms.reshape(-1)).rolling(rolling).mean()\n",
    "\n",
    "idx_12 = pd.date_range(ls_dates[0], periods=12, freq=\"2H\")\n",
    "min15_size = int((ma_rms.shape[0] - rolling + 1)/len(ls_dates)) #48\n",
    "min15_size_raw = int(bee_12h.shape[0]/len(ls_dates)) #48\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_figheight(10)\n",
    "fig.set_figwidth(16)\n",
    "\n",
    "\n",
    "ax3 = plt.subplot2grid(shape=(3, 5), loc=(0, 0), colspan=4)\n",
    "\n",
    "ax1 = plt.subplot2grid(shape=(3, 5), loc=(1, 0), colspan=4)\n",
    "ax2 = plt.subplot2grid(shape=(3, 5), loc=(2, 0), colspan=5)\n",
    "\n",
    "ax3.plot(bee_12h)\n",
    "ax3.set_ylabel('Intensity', size=14)#Amplitude\n",
    "ax3.set_xticks(np.arange(len(ls_dates)*min15_size_raw)[0:len(ls_dates)*min15_size_raw:4*min15_size_raw])\n",
    "ax3.set_xticklabels(idx_12.strftime('%H:%M'))\n",
    "ax3.axis(xmin=0,xmax=bee_12h.shape[-1])\n",
    "\n",
    "ax1.semilogy(ma_rms.T[rolling:], label='Beehive')\n",
    "ax1.set_xticks(np.arange(len(ls_dates)*min15_size)[0:len(ls_dates)*min15_size:4*min15_size]+rolling)\n",
    "ax1.set_xticklabels(idx_12.strftime('%H:%M'))\n",
    "\n",
    "ax1.set_ylabel('RMS', size=14)\n",
    "ax1.set_xticks(np.arange(len(ls_dates)*min15_size)[0:len(ls_dates)*min15_size:4*min15_size]+rolling)\n",
    "ax1.set_xticklabels(idx_12.strftime('%H:%M'))\n",
    "\n",
    "ax1.axis(xmin=rolling,xmax=ma_rms.shape[0])\n",
    "\n",
    "\n",
    "spec=librosa.display.specshow(librosa.amplitude_to_db(librosa.stft(bee_12h, n_fft=512), ref=np.max), sr=2048,  y_axis='log', cmap='jet')\n",
    "plt.colorbar(spec, format=\"%+2.0f dB\")\n",
    "min15_size = int((librosa.stft(bee_12h, n_fft=512).shape[1])/len(ls_dates)) #48\n",
    "\n",
    "ax2.set_xticks(np.arange(len(ls_dates)*min15_size)[0:len(ls_dates)*min15_size:4*min15_size]+rolling,)\n",
    "ax2.set_xticklabels(idx_12.strftime('%H:%M'))\n",
    "\n",
    "ax2.set_ylabel('Frequency (Hz)', size=14)\n",
    "ax2.set_xlabel('Time', size=14)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig('paper_spect_bee_'+ str(hive) + '_' + str(date) +'_' + 'rolling_' + str(rolling) +'.png')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "309f5a13",
   "metadata": {},
   "source": [
    "# Raw audio and rms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d34e8722",
   "metadata": {},
   "outputs": [],
   "source": [
    "win = 1600\n",
    "shift= 800\n",
    "\n",
    "\n",
    "rms_2021 = pd.read_pickle(\"../data/features/2021_df_raw_rms_win_\" + str(win) +'_shift_' + str(shift) +\"_pkl\")\n",
    "rms_2022 = pd.read_pickle(\"../data/features/2022_df_raw_rms_win_\" + str(win) +'_shift_' + str(shift) +\"_pkl\")\n",
    "\n",
    "rms_2021['date'] = pd.to_datetime(rms_2021['date'], dayfirst=True)\n",
    "rms_2021 = rms_2021.set_index(rms_2021['date'])\n",
    "rms_2021 = rms_2021.drop(['date'], axis=1)\n",
    "\n",
    "rms_2022['date'] = pd.to_datetime(rms_2022['date'], dayfirst=True)\n",
    "rms_2022 = rms_2022.set_index(rms_2022['date'])\n",
    "rms_2022 = rms_2022.drop(['date'], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "428411a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_all = rms_2021\n",
    "\n",
    "df_24h = pd.DataFrame(columns=df_all.columns)\n",
    "\n",
    "for hive in df_all[\"tag\"].unique():\n",
    "\n",
    "        print(hive)\n",
    "\n",
    "        df = df_all[df_all[\"tag\"]==hive].resample('h').mean()\n",
    "        df = df.dropna(how='all')\n",
    "\n",
    "        for date in np.unique(df.index.date):\n",
    "\n",
    "            temp_date = df.loc[str(date)]\n",
    "            #temp = temp.between_time(start, stop)\n",
    "            if len(temp_date) == 24:\n",
    "                #print(len(temp_date))\n",
    "                print(date)\n",
    "                print(len(temp_date))\n",
    "                \n",
    "                #df_24h = df_24h.drop(df_24h[(df_24h['tag'] == hive) & (df_24h.index.isin(temp_date.index))].index)\n",
    "                df_24h = df_24h.append(df.loc[str(date)])\n",
    "                #print(len(df_24h))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f35aa44",
   "metadata": {},
   "outputs": [],
   "source": [
    "for hive in df_24h[\"tag\"].unique():\n",
    "\n",
    "        print(hive)\n",
    "        #df = df_all[df_all[\"tag\"]==hive].resample('h').mean()\n",
    "        #df = df.dropna(how='all')\n",
    "        df = df_24h[df_24h[\"tag\"]==hive]\n",
    "        for date in np.unique(df.index.date):\n",
    "\n",
    "            temp_date = df.loc[str(date)]\n",
    "            #temp = temp.between_time(start, stop)\n",
    "            if len(temp_date) < 24:\n",
    "                #print(len(temp_date))\n",
    "                print(date)\n",
    "                "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41a25ff2",
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.rc('legend',fontsize=16) # using a size in points\n",
    "plt.rcParams['xtick.labelsize'] = 16\n",
    "plt.rcParams['ytick.labelsize'] = 16\n",
    "\n",
    "idx = [[10, 20], [20, 30], [1, 30]]\n",
    "\n",
    "index_mutual=df_24h[(10 < df_24h[\"fob\"]) &  (df_24h[\"fob\"] <= 20)].index.intersection(df_24h[(20 < df_24h[\"fob\"]) &  (df_24h[\"fob\"] <= 30)].index)\n",
    "\n",
    "for j in range(len(idx)):\n",
    "    \n",
    "    df_all_masked=df_24h[(idx[j][0] < df_24h[\"fob\"]) &  (df_24h[\"fob\"] <= idx[j][1])].loc[index_mutual]\n",
    "    print(df_all_masked['tag'].unique())\n",
    "    print(len(df_all_masked.index.date))\n",
    "    print(set(df_all_masked.index.unique().date))\n",
    "    print(len(df_all_masked.index.date)/df_all_masked['tag'].nunique()/24)\n",
    "    \n",
    "    #df_all_masked = df_all_masked.resample('h').mean()\n",
    "    fig, ax = plt.subplots(figsize=(12, 10))\n",
    "\n",
    "    res = df_all_masked.groupby(df_all_masked.index.hour).mean()\n",
    "    sns.barplot(data=res, x=res.index,  y='rms', color='steelblue')\n",
    "    plt.legend()\n",
    "    plt.xlabel('Time (hour)', size=22)\n",
    "    plt.ylabel('RMS', size=22)\n",
    "    plt.savefig('Average rms of bee hives_' + str(idx[j][0]) + \"_\" + str(idx[j][1])  + '_same_dates.png', dpi=400) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "217c3d10",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "614f3b11",
   "metadata": {},
   "source": [
    "# Spectral subtraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9de28e43",
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_rate=16000\n",
    "\n",
    "empty_name = \"12-08-2021_00h00_HIVE-0.wav\"\n",
    "hive_name = \"12-08-2021_00h00_HIVE-3631.wav\"\n",
    "signal_empty, sample_rate = librosa.load(os.path.join(\"../data/Nectar/full_2021/\", empty_name), sr=sample_rate)\n",
    "signal_bee, sample_rate = librosa.load(os.path.join(\"../data/Nectar/full_2021/\", hive_name), sr=sample_rate)\n",
    "shift = -1289884\n",
    "signal_empty_realigned = shift_signal(signal_empty, 1289884)[1289884:]\n",
    "signal_bee_realigned = signal_bee[1289884:]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8fd95c8f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "win_t = 30e-3#30e-3 # window size in seconds\n",
    "x_hat_mag = spectral_subtraction(signal_bee_realigned, snr_threshold=1.5, window_time=30e-3, sample_rate = sample_rate)\n",
    "\n",
    "plt.rc('legend',fontsize=18) # using a size in points\n",
    "plt.rcParams['xtick.labelsize'] = 16 \n",
    "plt.rcParams['ytick.labelsize'] = 16 \n",
    "\n",
    "sample_rate = 16000\n",
    "snr_threshold = 1.5 \n",
    "\n",
    "bins = np.arange(len(signal_bee_realigned))[0:(len(signal_bee_realigned)):16000*120]\n",
    "xlabels = [\"0\", \"2:00\", \"4:00\", \"6:00\", \"8:00\", \"10:00\", \"12:00\", \"14:00\"]\n",
    "\n",
    "fig, ax = plt.subplots(2, 1, figsize=(16,10), sharex=True)\n",
    "#fig.suptitle('Spectral subtraction', weight='bold', size=14)\n",
    "plt.ylim(-1,1)\n",
    "\n",
    "plt.legend()\n",
    "plt.subplot(2, 1, 1)\n",
    "plt.plot(signal_bee_realigned, label='Noisy signal', color='royalblue')\n",
    "plt.ylim(-1,1)\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(2, 1, 2)\n",
    "plt.plot(x_hat_mag, label='Filtered signal', color='cornflowerblue')\n",
    "plt.ylim(-1,1)\n",
    "\n",
    "plt.legend()\n",
    "plt.xticks(bins, xlabels[:len(bins)])\n",
    "plt.xlabel('Time (minute)', size=16)\n",
    "fig.supylabel('Amplitude', size=16)\n",
    "plt.savefig('ss_amp_filtered_' + hive_name[:-4] +'_snr_' + str(snr_threshold) + '.png', dpi=400)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70f756e9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "conda_env_3_8",
   "language": "python",
   "name": "conda_env_3_8"
  },
  "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.8.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}