initial commit

.gitignore

@@ -0,0 +1,15 @@
+DataSet/
+**/Data Processing/pretrained_models
+.ipynb_checkpoints
+**/Data Processing/.ipynb_checkpoints
+node_modules/
+Retraining Pipeline/models
+Retraining Pipeline/audio-diffusion
+Enhancement/
+ui/*.wav
+ui/*.npy
+
+input_songs/
+uploads/
+audio/
+__pycache__/

README.md

@@ -1,12 +1,52 @@
----
-title: Orpheus
-emoji: 🦀
-colorFrom: indigo
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.34.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Orpheus_ai- User Study
+
+## Introduction
+
+This repository hosts the code for conducting the user study for Orpheus_ai, a system designed for music generation. The user study aims to assess the efficacy of Orpheus_ai in creating music compositions.
+
+## Requirements
+
+Before initiating the user study, ensure the following prerequisites are met:
+
+1. **Install Required Packages:**
+
+    Set up a virtual environment and install the necessary packages using the provided `requirements.txt` file:
+    ```
+    pip install -r requirements.txt
+    ```
+
+    Alternatively, if you opt not to use a virtual environment, manually install the required versions of `diffusers` and `audiodiffusion` packages:
+    ```
+    pip install diffusers==0.17.1 audiodiffusion==1.5.6
+    ```
+
+    Note: Ensure compatibility between the installed Torch version and the CUDA version on your system since a GPU is necessary for running the code.
+
+2. **Create Folders for Data Storage:**
+
+    Create the following directory structure within the root directory for storing songs and spectrograms:
+    ```
+    DataSet
+    ├───Song
+    ├───Spec
+    ```
+
+## Usage
+
+To execute the user study and generate songs along with spectrograms, follow these steps:
+
+1. Navigate to the `ui` directory:
+    ```
+    cd ui
+    ```
+
+2. Launch the user study interface using Streamlit:
+    ```
+    streamlit run main.py
+    ```
+
+    Note: It's advisable to select only one song from the provided list during the initial phase. After generating the song and submitting the ratings, the resulting song and spectrogram will be saved in the respective folders. The files follow the naming convention:
+    ```
+    <model_name>_<song_name>_<similarity>_<rating>.wav
+    <model_name>_<song_name>_<similarity>_<rating>.npy
+    ```

Retraining Pipeline/retrain.ipynb

@@ -0,0 +1,102 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Cloning into 'audio-diffusion'...\n"
+     ]
+    }
+   ],
+   "source": [
+    "!git clone https://github.com/teticio/audio-diffusion\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Creating Dataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "python audio-diffusion/scripts/audio_to_images.py --resolution 256 --input_dir D:/Projects/Orpheus_ai/DataSet/Generated_music_withratings/training_samples/ --output_dir D:/Projects/Orpheus_ai/DataSet/Generated_music_withratings/train/ --push_to_hub SAint7579/orpheus_samples"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Retraining the model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "SyntaxError",
+     "evalue": "invalid syntax (<ipython-input-23-e665de61672a>, line 1)",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-23-e665de61672a>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    accelerate launch --config_file audio-diffusion/config/accelerate_local.yaml audio-diffusion/scripts/train_unet.py --dataset_name SAint7579/orpheus_samples --output_dir models/v1-0 --num_epochs 10 --train_batch_size 2  --eval_batch_size 2 --gradient_accumulation_steps 8 --learning_rate 1e-4 --mixed_precision no --push_to_hub True --hub_model_id SAint7579/orpheus_ldm_model_v1-0\u001b[0m\n\u001b[1;37m               ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
+     ]
+    }
+   ],
+   "source": [
+    "accelerate launch --config_file audio-diffusion/config/accelerate_local.yaml audio-diffusion/scripts/train_unet.py --dataset_name SAint7579/orpheus_samples --output_dir models/v1-0 --num_epochs 1 --train_batch_size 2  --eval_batch_size 2 --gradient_accumulation_steps 8 --learning_rate 1e-4 --mixed_precision no --push_to_hub True --hub_model_id SAint7579/orpheus_ldm_model_v1-0 --vae teticio/latent-audio-diffusion-256 --from_pretrained teticio/latent-audio-diffusion-256"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "--num_epochs 100 \\\n",
+    "--train_batch_size 2 \\\n",
+    "--eval_batch_size 2 \\\n",
+    "--gradient_accumulation_steps 8 \\\n",
+    "--learning_rate 1e-4 \\\n",
+    "--lr_warmup_steps 500 \\\n",
+    "--mixed_precision no \\\n",
+    "--push_to_hub True \\\n",
+    "--hub_model_id audio-diffusion-256 \\\n",
+    "--hub_token $(cat $HOME/.huggingface/token)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.8"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

Retraining Pipeline/sample_collection.ipynb

@@ -0,0 +1,332 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append('../')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "unet\\diffusion_pytorch_model.safetensors not found\n",
+      "unet\\diffusion_pytorch_model.safetensors not found\n"
+     ]
+    }
+   ],
+   "source": [
+    "import generation_utilities\n",
+    "import numpy as np\n",
+    "import librosa\n",
+    "from glob import glob\n",
+    "import random\n",
+    "import IPython.display as ipd\n",
+    "import soundfile as sf\n",
+    "import importlib\n",
+    "import ipywidgets as widgets\n",
+    "import numpy as np\n",
+    "importlib.reload(generation_utilities)\n",
+    "import os\n",
+    "os.environ[\"KMP_DUPLICATE_LIB_OK\"]=\"TRUE\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'22': '../input_songs\\\\22.mp3',\n",
+       " 'Anti-Hero': '../input_songs\\\\Anti-Hero.mp3',\n",
+       " 'Back-To-December': '../input_songs\\\\Back-To-December.mp3',\n",
+       " 'Blank-Space': '../input_songs\\\\Blank-Space.mp3',\n",
+       " 'Cardigan': '../input_songs\\\\Cardigan.mp3',\n",
+       " 'Delicate': '../input_songs\\\\Delicate.mp3',\n",
+       " 'Love-Story': '../input_songs\\\\Love-Story.mp3',\n",
+       " 'Lover': '../input_songs\\\\Lover.mp3',\n",
+       " 'uploaded_song': '../input_songs\\\\uploaded_song.mp3',\n",
+       " 'Willow': '../input_songs\\\\Willow.mp3',\n",
+       " 'You-Belong-With-Me': '../input_songs\\\\You-Belong-With-Me.mp3'}"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "music = glob(\"../input_songs/*.mp3\")\n",
+    "\n",
+    "## Create music dictionary with keys as song names and values as path\n",
+    "music_dict = {}\n",
+    "for song in music:\n",
+    "    song_name = song.split(\"\\\\\")[-1].split(\".\")[0]\n",
+    "    music_dict[song_name] = song\n",
+    "\n",
+    "music_dict"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_songs_as_numpy_array(song_dict):\n",
+    "    song_names = list(song_dict.keys())\n",
+    "    song_paths = list(song_dict.values())\n",
+    "\n",
+    "    song_selector = widgets.SelectMultiple(\n",
+    "        options=song_names,\n",
+    "        description='Select songs:',\n",
+    "        rows=len(song_names),\n",
+    "        layout=widgets.Layout(width='400px')\n",
+    "    )\n",
+    "\n",
+    "    ## Add a slider between 0 and 1 to select the similarity\n",
+    "    similarity_slider = widgets.FloatSlider(\n",
+    "        value=0.75,\n",
+    "        min=0,\n",
+    "        max=1.0,\n",
+    "        step=0.05,\n",
+    "        description='Similarity:',\n",
+    "        disabled=False,\n",
+    "        continuous_update=False,\n",
+    "        orientation='horizontal',\n",
+    "        readout=True,\n",
+    "        readout_format='.2f',\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "    select_button = widgets.Button(description='Select')\n",
+    "    output = widgets.Output()\n",
+    "\n",
+    "    def on_select_button_clicked(_):\n",
+    "        selected_songs = [librosa.load(song_paths[i], sr=22050)[0] for i in song_selector.index]      \n",
+    "        name = '+'.join([song_names[i] for i in song_selector.index])\n",
+    "\n",
+    "        with output:\n",
+    "            output.clear_output()\n",
+    "            print(f'Selected songs: {name}')\n",
+    "            ## Get similarity from the slider\n",
+    "            similarity = similarity_slider.value\n",
+    "            spec, song = generation_utilities.generate_songs(selected_songs, similarity=similarity, quality=500, merging_quality=100, device='cuda')\n",
+    "\n",
+    "            ## Play all the selected songs\n",
+    "            print(\"Selected songs: \")\n",
+    "            for s in selected_songs:\n",
+    "                ipd.display(ipd.Audio(s, rate=22050))\n",
+    "\n",
+    "            # Play song\n",
+    "            print(\"\\n\\nGenerated song: \")\n",
+    "            ipd.display(ipd.Audio(song, rate=22050))\n",
+    "\n",
+    "            ## Get a rating from the user with ipywidgets\n",
+    "            rating = widgets.Text(\n",
+    "                value='',\n",
+    "                placeholder='Type something',\n",
+    "                description='Rating:',\n",
+    "                disabled=False\n",
+    "            )\n",
+    "            display(rating)\n",
+    "            ## Make a submit button\n",
+    "            submit_button = widgets.Button(description='Submit')\n",
+    "            display(submit_button)\n",
+    "\n",
+    "            def on_submit_button_clicked(_):\n",
+    "                ## Convert rating to float\n",
+    "                rating_value = float(rating.value)\n",
+    "\n",
+    "                ## Save the song\n",
+    "                total_files = glob('../DataSet/Song/*')\n",
+    "                sf.write(f'../DataSet/Song/{len(total_files)}_{name}_{similarity}_{rating_value}.wav', song, 22050, 'PCM_24')\n",
+    "\n",
+    "                ## Save the spectrogram\n",
+    "                total_files = glob('../DataSet/Spec/*')\n",
+    "                np.save(f'../DataSet/Spec/{len(total_files)}_{name}_{similarity}_{rating_value}.npy', spec)\n",
+    "\n",
+    "                with output:\n",
+    "                    output.clear_output()\n",
+    "                    print(\"Saved\")\n",
+    "\n",
+    "\n",
+    "            submit_button.on_click(on_submit_button_clicked)\n",
+    "        \n",
+    "    select_button.on_click(on_select_button_clicked)\n",
+    "\n",
+    "    display(song_selector)\n",
+    "    display(select_button)\n",
+    "    display(similarity_slider)\n",
+    "    display(output)\n",
+    "\n",
+    "\n",
+    "    # return selected_songs, name\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c2beb314b7784af097f04ad2bfd70046",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "SelectMultiple(description='Select songs:', layout=Layout(width='400px'), options=('22', 'Anti-Hero', 'Back-To…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2edb699552dd4196bec2683395fc0f11",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Button(description='Select', style=ButtonStyle())"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "80b12515c92242ffa9483eb3982464a2",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "FloatSlider(value=0.75, continuous_update=False, description='Similarity:', max=1.0, step=0.05)"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ef000bfed4b94491931224b0cb0ce823",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "load_songs_as_numpy_array(music_dict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "os.environ['KMP_DUPLICATE_LIB_OK'] = 'TRUE'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Merging songs...\n",
+      "Generating song...\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7ea21aa7cb7249d4ba35c63506cf0031",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/100 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "(<PIL.Image.Image image mode=L size=256x256>,\n",
+       " array([-2.02207055e-04, -9.85335573e-05, -1.04858875e-04, ...,\n",
+       "        -2.07161275e-03, -6.43183384e-03, -6.42244611e-03], dtype=float32))"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "generation_utilities.generate_songs([librosa.load(music_dict[\"22\"], sr=22050)[0]]     ,)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from streamlit_extras.switch_page_button import switch_page\n",
+    "\n",
+    "switch_page(\"New page name\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

change_song.py

@@ -0,0 +1,273 @@
+import warnings
+import psycopg2
+from io import BytesIO
+from diffusers.configuration_utils import ConfigMixin, register_to_config
+from diffusers.schedulers.scheduling_utils import SchedulerMixin
+from scipy.io import wavfile
+import soundfile as sf
+import os
+warnings.filterwarnings("ignore")
+import sys
+from generation_utilities import *
+
+import numpy as np  # noqa: E402
+from PIL import Image  # noqa: E402
+
+import shutil
+import torch
+from IPython.display import Audio
+from audiodiffusion import AudioDiffusion, AudioDiffusionPipeline
+from audiodiffusion.audio_encoder import AudioEncoder
+import librosa
+import librosa.display
+
+import IPython.display as ipd
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+# audio_diffusion = AudioDiffusionPipeline.from_pretrained("teticio/latent-audio-diffusion-256").to(device)
+audio_diffusion = AudioDiffusionPipeline.from_pretrained("SAint7579/orpheus_ldm_model_v1-0").to(device)
+ddim = AudioDiffusionPipeline.from_pretrained("teticio/audio-diffusion-ddim-256").to(device)
+
+
+
+
+
+try:
+    import librosa  # noqa: E402
+
+    _librosa_can_be_imported = True
+    _import_error = ""
+except Exception as e:
+    _librosa_can_be_imported = False
+    _import_error = (
+        f"Cannot import librosa because {e}. Make sure to correctly install librosa to be able to install it."
+    )
+
+
+class Mel(ConfigMixin, SchedulerMixin):
+    """
+    Parameters:
+        x_res (`int`): x resolution of spectrogram (time)
+        y_res (`int`): y resolution of spectrogram (frequency bins)
+        sample_rate (`int`): sample rate of audio
+        n_fft (`int`): number of Fast Fourier Transforms
+        hop_length (`int`): hop length (a higher number is recommended for lower than 256 y_res)
+        top_db (`int`): loudest in decibels
+        n_iter (`int`): number of iterations for Griffin Linn mel inversion
+    """
+
+    config_name = "mel_config.json"
+
+    @register_to_config
+    def __init__(
+        self,
+        x_res: int = 256,
+        y_res: int = 256,
+        sample_rate: int = 22050,
+        n_fft: int = 2048,
+        hop_length: int = 512,
+        top_db: int = 80,
+        n_iter: int = 32,
+    ):
+        self.hop_length = hop_length
+        self.sr = sample_rate
+        self.n_fft = n_fft
+        self.top_db = top_db
+        self.n_iter = n_iter
+        self.set_resolution(x_res, y_res)
+        self.audio = None
+
+        if not _librosa_can_be_imported:
+            raise ValueError(_import_error)
+
+    def set_resolution(self, x_res: int, y_res: int):
+        """Set resolution.
+
+        Args:
+            x_res (`int`): x resolution of spectrogram (time)
+            y_res (`int`): y resolution of spectrogram (frequency bins)
+        """
+        self.x_res = x_res
+        self.y_res = y_res
+        self.n_mels = self.y_res
+        self.slice_size = self.x_res * self.hop_length - 1
+
+    def load_audio(self, audio_file: str = None, raw_audio: np.ndarray = None):
+        """Load audio.
+
+        Args:
+            audio_file (`str`): must be a file on disk due to Librosa limitation or
+            raw_audio (`np.ndarray`): audio as numpy array
+        """
+        if audio_file is not None:
+            self.audio, _ = librosa.load(audio_file, mono=True, sr=self.sr)
+        else:
+            self.audio = raw_audio
+
+        # Pad with silence if necessary.
+        if len(self.audio) < self.x_res * self.hop_length:
+            self.audio = np.concatenate([self.audio, np.zeros((self.x_res * self.hop_length - len(self.audio),))])
+
+    def get_number_of_slices(self) -> int:
+        """Get number of slices in audio.
+
+        Returns:
+            `int`: number of spectograms audio can be sliced into
+        """
+        return len(self.audio) // self.slice_size
+
+    def get_audio_slice(self, slice: int = 0) -> np.ndarray:
+        """Get slice of audio.
+
+        Args:
+            slice (`int`): slice number of audio (out of get_number_of_slices())
+
+        Returns:
+            `np.ndarray`: audio as numpy array
+        """
+        return self.audio[self.slice_size * slice : self.slice_size * (slice + 1)]
+
+    def get_sample_rate(self) -> int:
+        """Get sample rate:
+
+        Returns:
+            `int`: sample rate of audio
+        """
+        return self.sr
+
+    def audio_slice_to_image(self, slice: int, ref=np.max) -> Image.Image:
+        """Convert slice of audio to spectrogram.
+
+        Args:
+            slice (`int`): slice number of audio to convert (out of get_number_of_slices())
+
+        Returns:
+            `PIL Image`: grayscale image of x_res x y_res
+        """
+        S = librosa.feature.melspectrogram(
+            y=self.get_audio_slice(slice), sr=self.sr, n_fft=self.n_fft, hop_length=self.hop_length, n_mels=self.n_mels
+        )
+        log_S = librosa.power_to_db(S, ref=ref, top_db=self.top_db)
+        bytedata = (((log_S + self.top_db) * 255 / self.top_db).clip(0, 255) + 0.5).astype(np.uint8)
+        image = Image.fromarray(bytedata)
+        return image
+
+    def image_to_audio(self, image: Image.Image) -> np.ndarray:
+        """Converts spectrogram to audio.
+
+        Args:
+            image (`PIL Image`): x_res x y_res grayscale image
+
+        Returns:
+            audio (`np.ndarray`): raw audio
+        """
+        bytedata = np.frombuffer(image.tobytes(), dtype="uint8").reshape((image.height, image.width))
+        log_S = bytedata.astype("float") * self.top_db / 255 - self.top_db
+        S = librosa.db_to_power(log_S)
+        audio = librosa.feature.inverse.mel_to_audio(
+            S, sr=self.sr, n_fft=self.n_fft, hop_length=self.hop_length, n_iter=self.n_iter
+        )
+        return audio
+
+def audioarray_to_mp3(audioarray, file_path):
+    sample_rate = 22050
+    mel = Mel()
+    # Save the audio array as a temporary WAV file
+    temp_wav_file = "temp.wav"
+    wavfile.write(temp_wav_file, sample_rate, audioarray)
+
+    # Set the output MP3 file path
+    os.remove(file_path)
+    output_mp3_file = file_path
+
+    # Load the temporary WAV file
+    wav_data, sr = sf.read(temp_wav_file)
+
+    # Convert the WAV data to MP3 format
+    sf.write(output_mp3_file, wav_data, sample_rate, format="MP3")
+    
+    return None
+
+def audioarray_to_mp3_highdb(audioarray, file_path):
+    sample_rate = 22050
+    # Save the audio array as a temporary WAV file
+    temp_wav_file = "temp.wav"
+
+    audio = ipd.Audio(audioarray, rate=sample_rate)
+
+    ## Write file into a wav file with open
+    with open(file_path, 'wb') as f:
+        f.write(audio.data)
+        
+    return None
+
+
+def main():
+    # # Connect to the PostgreSQL database
+    # conn = psycopg2.connect(database="orpheus", user="postgres", password="1234", host="localhost", port="5432")
+    # cur = conn.cursor()
+
+    # # Assuming you have a table named 'images' with columns 'id' (serial primary key) and 'image_data' (bytea)
+    # table_name = "songs"
+    
+    # image_id = np.random.randint(1, 10)  # Replace with the actual ID of the image you want to retrieve
+    # print(image_id)
+    # # Retrieve the image data from the database
+    # cur.execute(f"SELECT song FROM {table_name} WHERE id = %s", (image_id,))
+    # result = cur.fetchone()
+
+    # # Convert the bytea data to PIL.Image.Image object
+    # image_bytes = BytesIO(result[0])
+    # image = Image.open(image_bytes)
+    # # image.save("C:/VS code projects/Orpheus-2/audio/thumbnail.png")
+    # # Close the database connection
+    # cur.close()
+    # conn.close()
+    
+    # getting the song names
+    song1_name=sys.argv[1]
+    song2_name=sys.argv[2]
+    song3_name=sys.argv[3]
+    similarity_index=float(sys.argv[4])/100
+    print("Similarity index is",similarity_index)
+    print("Song1 name is",song1_name)
+    print("Song2 name is",song2_name)
+    print("Song3 name is",song3_name)
+    print("Similarity index is",similarity_index)
+    #
+    mel = Mel()
+    # audioarray_to_mp3(mel.image_to_audio(image), "audio/output.mp3")
+    # song_array_1, sr = librosa.load("audio\output.mp3", sr=22050)
+    # song_array_1 = song_array_1[:sr*5]
+    
+    input_songs_array = []
+    
+    if song1_name != "None":
+        song_array_1, sr = librosa.load(f"input_songs/{song1_name}.mp3", sr=22050)
+        input_songs_array.append(song_array_1)
+    # song_array_1, sr = librosa.load(f"input_songs/{song1_name}.mp3", sr=22050)
+    
+    # song_array_1 = song_array_1[:sr*5]
+    if song2_name != "None":
+        song_array_2, sr = librosa.load(f"input_songs/{song2_name}.mp3", sr=22050)
+        input_songs_array.append(song_array_2)
+    
+    # song_array_2, sr = librosa.load(f"input_songs/{song2_name}.mp3", sr=22050)
+    # song_array_2 = song_array_2[:sr*5]
+    
+    if song3_name != "None":
+        song_array_3, sr = librosa.load(f"input_songs/{song3_name}.mp3", sr=22050)
+        input_songs_array.append(song_array_3)
+    # song_array_3, sr = librosa.load(f"input_songs/{song3_name}.mp3", sr=22050)
+    # song_array_3 = song_array_3[:sr*5]
+    mage, audio = generate_songs(input_songs_array, similarity=similarity_index, quality=200)
+    mage.save("audio/thumbnail.png")
+    audioarray_to_mp3_highdb(audio,"audio/generated_song.mp3")
+    # if i==3:
+    #     shutil.copy2("aidio/nvg.mp3", "audio/generated_song.mp3")
+    
+    print("Python script executed successfully")
+
+if __name__ == "__main__":
+    main()

exp.ipynb

@@ -0,0 +1,224 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import glob\n",
+    "import matplotlib.pyplot as plt "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "songs = glob.glob(\"DataSet/srija/*.wav\")\n",
+    "ratings = [s.split(\"_\")[-1].split(\".\")[0] for s in songs]\n",
+    "ratings = np.array(ratings, dtype=int)\n",
+    "version = [s.split(\"_\")[1][-2:] for s in songs]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "rr =pd.DataFrame({\"rating\": ratings, \"version\": version})\n",
+    "\n",
+    "# plt = rr.groupby([\"version\"])[\"ratings\"].mean().plot(kind='bar', stacked=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>rating</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>version</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>v0</th>\n",
+       "      <td>4.740741</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>v1</th>\n",
+       "      <td>4.703704</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           rating\n",
+       "version          \n",
+       "v0       4.740741\n",
+       "v1       4.703704"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "rr.groupby([\"version\"]).mean()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<BarContainer object of 54 artists>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.bar(rr[\"version\"], rr[\"rating\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "avg_ratings = {}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import glob\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Get the list of song files\n",
+    "songs = glob.glob(\"DataSet/srija/*.wav\")\n",
+    "\n",
+    "# Extract ratings and versions\n",
+    "ratings = [int(s.split(\"_\")[-1].split(\".\")[0]) for s in songs]\n",
+    "version = [s.split(\"_\")[1][-2:] for s in songs]\n",
+    "\n",
+    "# Create a dictionary to store ratings for each version\n",
+    "ratings_by_version = {}\n",
+    "\n",
+    "# Iterate over songs and populate ratings by version dictionary\n",
+    "for v, r in zip(version, ratings):\n",
+    "    if v not in ratings_by_version:\n",
+    "        ratings_by_version[v] = []\n",
+    "    ratings_by_version[v].append(r)\n",
+    "\n",
+    "# Calculate average ratings for each version\n",
+    "avg_ratings = {v: sum(ratings) / len(ratings) for v, ratings in ratings_by_version.items()}\n",
+    "\n",
+    "# Plotting\n",
+    "plt.bar(avg_ratings.keys(), avg_ratings.values(), color='skyblue')\n",
+    "plt.xlabel('Version')\n",
+    "plt.ylabel('Average Rating')\n",
+    "plt.title('Average Rating by Version')\n",
+    "plt.xticks(list(avg_ratings.keys()))\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "lmu310",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

generation_utilities.py

@@ -0,0 +1,201 @@
+import torch
+from IPython.display import Audio
+from audiodiffusion import AudioDiffusion, AudioDiffusionPipeline
+from audiodiffusion.audio_encoder import AudioEncoder
+import librosa
+import librosa.display
+import numpy as np
+import random 
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+model_name = ["SAint7579/orpheus_ldm_model_v1-0", "teticio/audio-diffusion-ddim-256"]
+
+audio_diffusion_v0 = AudioDiffusionPipeline.from_pretrained("teticio/latent-audio-diffusion-256").to(device)
+audio_diffusion_v1 = AudioDiffusionPipeline.from_pretrained("SAint7579/orpheus_ldm_model_v1-0").to(device)
+ddim = AudioDiffusionPipeline.from_pretrained("teticio/audio-diffusion-ddim-256").to(device)
+
+### Add numpy docstring to generate_from_music
+def generate_from_music(song_array, diffuser, start_step, total_steps=100, device="cuda"):
+    """
+    Generates audio from a given song array using a given diffuser.
+    Parameters
+    ----------
+    song_array : numpy.ndarray
+        The song array to use as the raw audio.
+    diffuser : AudioDiffusionPipeline
+        The diffuser to use to generate the audio.
+    start_step : int
+        The step to start generating from.
+    total_steps : int
+        The total number of steps to generate.
+    device : str
+        The device to use for generation.
+    Returns
+    -------
+    numpy.ndarray
+        The generated audio.
+    """
+    generator = torch.Generator(device=device)
+    generator.seed()
+    output = diffuser(raw_audio=song_array, generator = generator, start_step=start_step, steps=total_steps)
+    return output.images[0], output.audios[0, 0]
+
+def generate_from_music_long(song_array, diffuser, start_step, total_steps=100, device="cuda"):
+    """
+    Generates a 10 second audio from a given song array using a given diffuser.
+    Parameters
+    ----------
+    song_array : numpy.ndarray
+        The song array to use as the raw audio.
+    diffuser : AudioDiffusionPipeline
+        The diffuser to use to generate the audio.
+    start_step : int
+        The step to start generating from.
+    total_steps : int
+        The total number of steps to generate.
+    device : str
+        The device to use for generation.
+    Returns
+    -------
+    numpy.ndarray
+        The generated audio.
+    """
+    generator = torch.Generator(device=device)
+    generator.seed()
+    output = diffuser(raw_audio=song_array, generator = generator, start_step=start_step, steps=total_steps)
+
+    # Get the track and use the diffuser again to create the continuation
+    track = output.audios[0, 0]
+    sample_rate = diffuser.mel.get_sample_rate()
+    overlap_secs = 2
+    overlap_samples = overlap_secs * sample_rate
+
+    continue_output = diffuser(raw_audio=track[-overlap_samples:],
+                               generator=generator,
+                               start_step=start_step,
+                               mask_start_secs=overlap_secs)
+    # image2 = output.images[0]
+    audio2 = continue_output.audios[0, 0]
+    track = np.concatenate([track, audio2[overlap_samples:]])
+
+    return output.images[0], track
+
+
+## Add docstring to iterative_slerp function in numpy format
+def iterative_slerp(song_arrays, ddim, steps=10):
+    """Iterative slerp function.
+
+    Parameters
+    ----------
+    song_arrays : list
+        List of song arrays to slerp.
+    ddim : AudioDiffusion ddim model
+        AudioDiffusion object.
+
+    Returns
+    -------
+    slerp : torch.Tensor
+        Slerped tensor.
+    """
+    noise = []
+    for arr in song_arrays:
+        ddim.mel.audio = arr
+        noise.append(ddim.encode([ddim.mel.audio_slice_to_image(0)], steps=steps))
+
+    slerp = noise[0]
+    for i in range(1, len(noise)):
+        slerp = ddim.slerp(slerp, noise[i], 0.5)
+
+    return slerp
+
+def merge_songs(song_arrays, ddim, slerp_steps=10, diffusion_steps=100, device="cuda"):
+    """Merge songs.
+
+    Parameters
+    ----------
+    song_arrays : list
+        List of song arrays to merge.
+    ddim : AudioDiffusion ddim model
+        AudioDiffusion object.
+
+    Returns
+    -------
+    spectrogram : np.ndarray
+        Merged spectrogram.
+    audio : np.ndarray
+        Merged audio.
+    """
+    generator = torch.Generator(device=device)
+    generator.manual_seed(7579)
+    slerp = iterative_slerp(song_arrays, ddim, slerp_steps)
+    merged = ddim(noise=slerp, generator=generator, steps=diffusion_steps)
+    return merged.images[0], merged.audios[0, 0]
+
+## Write generate songs function with numpy docstring
+def generate_songs(conditioning_songs, similarity=0.9, quality=500, merging_quality=100, device='cuda'):
+    """Generate songs.
+
+    Parameters
+    ----------
+    conditioning_songs : list
+        List of conditioning songs.
+    similarity : float
+        Similarity between conditioning songs.
+    quality : int
+        Quality of generated song.
+
+    Returns
+    -------
+    spec_generated : np.ndarray
+        Spectrogram of generated song.
+    generated : np.ndarray
+        Generated song.
+    """
+    ## Merging songs
+    print("Merging songs...")
+    if len(conditioning_songs)>1:
+        # print(conditioning_songs)
+        # for c in conditioning_songs:
+        #     print(len(c))
+        spec_merged, merged = merge_songs(conditioning_songs, ddim, slerp_steps=merging_quality, diffusion_steps=merging_quality, device=device)
+    else:
+        merged = conditioning_songs[0]
+
+    ## Take a random 10 second slice from the merged song
+    # sample_rate = ddim.mel.get_sample_rate()
+    # start = np.random.randint(0, len(merged) - 5 * sample_rate)
+    # merged = merged[start:start + 5 * sample_rate]
+
+    if random.random() < 0.5:
+        diffuser = audio_diffusion_v0
+        model_name = "v0"
+    else:
+        diffuser = audio_diffusion_v1
+        model_name = "v1"
+    print("Generating song...")
+    ## quality = X - similarity*X
+    total_steps = min([1000, int(quality/(1-similarity))])
+    start_step = int(total_steps*similarity)
+    spec_generated, generated = generate_from_music(merged, diffuser, start_step=start_step, total_steps=total_steps, device=device)
+
+    return spec_generated, generated, model_name
+
+# if __name__ == '__main__':
+#     song1 = "D:/Projects/Orpheus_ai/DataSet/Sep_Dataset/accompaniment/000010.mp3"
+#     song2 = "D:/Projects/Orpheus_ai/DataSet/Sep_Dataset/accompaniment/000002.mp3"
+#     song3 = "D:/Projects/Orpheus_ai/DataSet/Sep_Dataset/accompaniment/000003.mp3"
+
+#     song_array_1, sr = librosa.load(song1, sr=22050)
+#     song_array_1 = song_array_1[:sr*5]
+
+#     song_array_2, sr = librosa.load(song2, sr=22050)
+#     song_array_2 = song_array_2[:sr*10]
+
+#     song_array_3, sr = librosa.load(song3, sr=22050)
+#     song_array_3 = song_array_3[:sr*10]
+
+#     generator = torch.Generator(device=device)
+
+#     # seed = 239150437427
+#     image, audio = generate_songs([song_array_2, song_array_3], similarity=0.5, quality=10, device=device)
+#     Audio(audio, rate=sr)

requirements.txt

@@ -0,0 +1,10 @@
+audiodiffusion==1.5.6
+diffusers==0.17.1
+librosa==0.10.1
+numpy==1.26.2
+torch==2.2.1+cu118
+torchaudio==2.2.1+cu118
+torchmetrics==1.3.1
+torchvision==0.17.1
+streamlit==1.32.2
+st-star-rating==0.0.6

ui/app.py

@@ -0,0 +1,55 @@
+import streamlit as st
+st.set_page_config(initial_sidebar_state="collapsed")
+import sys
+sys.path.append('../')
+import generation_utilities
+import numpy as np
+import librosa
+from glob import glob
+import soundfile as sf
+import importlib
+import numpy as np
+importlib.reload(generation_utilities)
+
+import os
+os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
+
+
+if 'song_name' not in st.session_state:
+    st.session_state['song_name'] = None
+if 'similarity' not in st.session_state:
+    st.session_state['similarity'] = None
+if 'model_name' not in st.session_state:
+    st.session_state['model_name'] = None
+if 'song_list' not in st.session_state:
+    st.session_state['song_list'] = None
+
+
+form1 = st.form(key="form1")
+song_default = np.random.choice(["22", "Anti-Hero", "Back-to-december","Blank-Space","Cardigan","Delicate","Lover","Love-Story","Willow","You-Belong-With-Me"])
+similarity_default = np.random.uniform(0.8, 0.99).__round__(2)
+song_options = form1.multiselect("Select songs from library",["22", "Anti-Hero", "Back-to-december","Blank-Space","Cardigan","Delicate","Lover","Love-Story","Willow","You-Belong-With-Me"], default=[song_default])
+similarity = form1.slider("Similarity", 0.0, 1.0, similarity_default)
+submit = form1.form_submit_button("Submit")
+
+if submit:
+    song_list = [librosa.load(f"../input_songs/{song}.mp3", sr=22050)[0] for song in song_options]
+    print(song_options)
+    
+    spectrogram, generated_song, model_name = generation_utilities.generate_songs(song_list, similarity=similarity, quality=500, merging_quality=100, device='cuda')
+    st.session_state['song_name'] = song_options[0]
+    st.session_state['song_list'] = [f"../input_songs/{song}.mp3" for song in song_options]
+    st.session_state['song_name'] = '_'.join(song_options)
+    st.session_state['similarity'] = similarity
+    st.session_state['model_name'] = model_name
+    
+    # saving temps
+    sf.write(f"temp.wav", generated_song, 22050)
+    np.save("temp.npy", spectrogram)
+    st.switch_page("pages/rating.py")
+    # st.audio(generated_song, format='audio/wav',sample_rate=22050)
+    
+    # generated_audio_path = "generated_audio.wav"
+    # sf.write(generated_audio_path, generated_song, 22050)
+    # st.audio(generated_audio_path, format='audio/wav')
+    # st.write("Generated!")

ui/pages/rating.py

@@ -0,0 +1,25 @@
+import streamlit as st
+from streamlit_star_rating import st_star_rating
+st.set_page_config(initial_sidebar_state="collapsed")
+import glob
+import shutil
+import sys
+sys.path.append('../../')
+spectrograms = glob.glob("temp*.npy")
+generated_songs = glob.glob("temp*.wav")
+
+st.markdown("# Original Song")
+for s in st.session_state['song_list']:
+    st.markdown(f"### {s.split('/')[-1].split('.')[0]}")
+    st.audio(s, format='audio/wav')
+st.markdown("# Generated Song")
+st.audio(generated_songs[0], format='audio/wav')
+rating = st_star_rating(label="rating", maxValue=10, defaultValue=3)
+
+
+submit_rating = st.button("Submit Rating")
+
+if submit_rating:
+    shutil.copy(generated_songs[0],f"../DataSet/Song/srija_{st.session_state['model_name']}_{st.session_state['song_name']}_{st.session_state['similarity']}_{rating}.wav")
+    shutil.copy(spectrograms[0],f"../DataSet/Spec/srija_{st.session_state['model_name']}_{st.session_state['song_name']}_{st.session_state['similarity']}_{rating}.npy")
+    st.switch_page("app.py")