assets/landscapes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "84b6b372-c1fc-4bfc-bd57-cb869b56af0f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.interpolate import RectBivariateSpline\n",
    "import random\n",
    "import os\n",
    "\n",
    "from keras.layers import Input, Dense\n",
    "from keras.models import Model, Sequential\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import metrics\n",
    "\n",
    "from IPython.display import display, clear_output\n",
    "from PIL import Image, ImageSequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c47cd4e5-b185-49a8-b57e-734c7e0bfa47",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPU 0: NVIDIA A100-PCIE-40GB (UUID: GPU-a8053574-4128-877c-acfd-80334fa7cd5d)\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi -L # list GPUs available"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e230c08e-42ca-4086-ba2c-e2cab70248f9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!export CUDA_VISIBLE_DEVICES=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "649e940b-e9ff-4522-ae65-3b44946b38f2",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "mass_range = [0,0.5,1,1.5,2,2.5,3,3.5,4,4.5,5,5.5,6]\n",
    "\n",
    "x = {}\n",
    "x_array_read = np.load(\"x_array_order.npy\",allow_pickle=True)\n",
    "mycounter = -1\n",
    "for m1 in mass_range:\n",
    "    for m2 in mass_range:\n",
    "        if (m1==0 and m2>0 or m2==0 and m1>0):\n",
    "            continue\n",
    "        mycounter+=1\n",
    "        x[m1,m2] = x_array_read[mycounter]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6a2df76f-d755-4ce1-973a-b47406bec937",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.shape(x[0,0,qq, noise])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3d38a8d-7974-422a-85af-eb3d19a1b32d",
   "metadata": {},
   "source": [
    "Below we evaluate every point in our discritized space of weights and store to a dictionary, evaluation can be stopped at any point, saving after every signal fraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "9c5f3cde-4b4f-43ae-af8b-6086e0bc76ce",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Signal Fraction:  0.001\n",
      "Signal Fraction:  0.0012742749857031334\n",
      "Signal Fraction:  0.001623776739188721\n",
      "Signal Fraction:  0.00206913808111479\n",
      "Signal Fraction:  0.0026366508987303583\n",
      "Signal Fraction:  0.003359818286283781\n",
      "Signal Fraction:  0.004281332398719396\n",
      "Signal Fraction:  0.00545559478116852\n",
      "Signal Fraction:  0.0069519279617756054\n",
      "Signal Fraction:  0.008858667904100823\n",
      "Signal Fraction:  0.011288378916846888\n",
      "Signal Fraction:  0.01438449888287663\n",
      "Signal Fraction:  0.018329807108324356\n",
      "Signal Fraction:  0.023357214690901212\n",
      "Signal Fraction:  0.029763514416313176\n",
      "Signal Fraction:  0.0379269019073225\n",
      "Signal Fraction:  0.04832930238571752\n",
      "Signal Fraction:  0.06158482110660261\n",
      "Signal Fraction:  0.07847599703514611\n",
      "Signal Fraction:  0.1\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "start_time = time.time()\n",
    "\n",
    "def evaluate_loss_landscape(model, m1, m2):\n",
    "    \n",
    "    Nfeatures = 6\n",
    "    #check if loss dictionary exists, if it does load it, if not create empty one\n",
    "    dir_path = os.getcwd()\n",
    "    file_name = f\"z_allm1m2_{Nfeatures}FeaturesHD.npy\"\n",
    "    file_path = os.path.join(dir_path, file_name)\n",
    "    \n",
    "    if os.path.exists(file_path):\n",
    "        z = np.load(file_name, allow_pickle = True).item()\n",
    "    else:\n",
    "        print(\"Dictionary doesn't exist, creating one...\")\n",
    "        z = {}\n",
    "    #varying sigfrac, fixed mass pair\n",
    "    \n",
    "    losses_list = []\n",
    "\n",
    "    epsilon = 1e-6\n",
    "    sig_space = np.logspace(-3, -1, 10)\n",
    "    \n",
    "    #if we want a specific sigfrac\n",
    "    #sig_space = [sig_space[15]]\n",
    "    \n",
    "    start = 0.5\n",
    "    end = 6\n",
    "    step = 0.25\n",
    "\n",
    "    weight_list = np.arange(start, end + step, step)\n",
    "    \n",
    "    for sig in sig_space:\n",
    "        print(\"Signal Fraction: \", sig)\n",
    "        for w1 in weight_list:\n",
    "            for w2 in weight_list:\n",
    "                #print(w1, w2)\n",
    "                sigfrac = sig\n",
    "\n",
    "                for l in model.layers:\n",
    "                    l.trainable=False\n",
    "\n",
    "                inputs_hold = tf.keras.Input(shape=(1,))\n",
    "                simple_model = Dense(1,use_bias = False,activation='relu',kernel_initializer=tf.keras.initializers.Constant(w1))(inputs_hold)\n",
    "                model3 = Model(inputs = inputs_hold, outputs = simple_model)\n",
    "\n",
    "                inputs_hold2 = tf.keras.Input(shape=(1,))\n",
    "                simple_model2 = Dense(1,use_bias = False,activation='relu',kernel_initializer=tf.keras.initializers.Constant(w2))(inputs_hold2)\n",
    "                model32 = Model(inputs = inputs_hold2, outputs = simple_model2)\n",
    "\n",
    "                inputs_hold3 = tf.keras.Input(shape=(1,))\n",
    "                simple_model3 = tf.exp(Dense(1,use_bias = False,activation='linear',kernel_initializer=tf.keras.initializers.Constant(-1))(inputs_hold3))\n",
    "                model33 = Model(inputs = inputs_hold3, outputs = simple_model3)\n",
    "\n",
    "                inputs = tf.keras.Input(shape=(Nfeatures,))\n",
    "                inputs2 = tf.keras.layers.concatenate([inputs,model3(tf.ones_like(inputs)[:,0]),model32(tf.ones_like(inputs)[:,0])])\n",
    "                hidden_layer_1 = model(inputs2)\n",
    "                LLR = hidden_layer_1 / (1.-hidden_layer_1 + epsilon)\n",
    "                LLR_xs = 1.+sigfrac*LLR - sigfrac\n",
    "                #LLR_xs = 1.+model33(tf.ones_like(inputs)[:,0])*LLR\n",
    "                ws = LLR_xs / (1.+LLR_xs+0.0001)\n",
    "                model_all2 = Model(inputs = inputs, outputs = ws)\n",
    "                model_all2.compile(loss='binary_crossentropy', optimizer=tf.keras.optimizers.Adam(learning_rate = 0.01))\n",
    "\n",
    "                m1 = m1\n",
    "                m2 = m2\n",
    "                \n",
    "                #if computed this mass pair, break\n",
    "                \n",
    "                key = (sigfrac,m1,m2)\n",
    "                if key in z:\n",
    "                    break\n",
    "\n",
    "                test_background = int(1/2 *len(x[0,0, qq]))\n",
    "                train_background = int(1/4 * len(x[0,0,qq]))\n",
    "                train_data = int(1/4 * len(x[0,0,qq]))\n",
    "                train_reference = int(1/4 * len(x[0,0,qq]))\n",
    "                #signal\n",
    "                test_signal_length = int(1/2*len(x[m1,m2,qq]))\n",
    "                sig_frac = sigfrac\n",
    "\n",
    "                #randomize signal events\n",
    "                #random_test_signal_length = random.randint(0, test_signal_length - 1)\n",
    "                N = int(1/4 * (len(x[0,0,qq])))\n",
    "                signal = x[m1, m2,qq][test_signal_length:test_signal_length + int(sigfrac*N)]\n",
    "\n",
    "                x_vals_ = np.concatenate([x[0,0,qq][test_background:],signal])\n",
    "                y_vals_ = np.concatenate([np.zeros(train_reference),np.ones(train_data),np.ones(len(signal))])\n",
    "\n",
    "                X_train_, X_val_, Y_train_, Y_val_ = train_test_split(x_vals_, y_vals_, test_size=0.5, random_state = 42)\n",
    "                \n",
    "                with tf.device('/GPU:0'):\n",
    "                    loss = model_all2.evaluate(X_val_, Y_val_, verbose = 0)\n",
    "                losses_list.append(loss)\n",
    "                \n",
    "        end_time = time.time()\n",
    "        elapsed_time = round(end_time - start_time, 3)\n",
    "        print(f\"Time taken: {elapsed_time} seconds\")\n",
    "        if key in z:\n",
    "            print(\"Landscape for m1 = {} \".format(m1) + \"and \" + \"m2 = {} \".format(m2) +\" already exists for \" + \"{}\".format(sigfrac) + \" signal fraction\")\n",
    "        else:\n",
    "            z[sigfrac, m1, m2] = losses_list\n",
    "            losses_list = []\n",
    "            np.save(file_name, z)\n",
    "end_time_total = time.time()\n",
    "\n",
    "elapsed_time_total = round(end_time_total - start_time, 3)\n",
    "print(f\"Total elapsed time: {elapsed_time_total} seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "58706d19-144e-4503-a46a-79e106e2b1bd",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "loss_values = list(z[sig_space[0], 1, 5.5])\n",
    "\n",
    "plt.hist2d(m1_values, m2_values, bins=(12, 12), cmap='viridis', weights=loss_values);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf2dd2dd-5d9f-4ca8-8a76-a41a5b80c9dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "def loss_landscape_nofit(sigfrac, m1, m2, z, step=0.25):\n",
    "    start = 0.5\n",
    "    end = 6\n",
    "    step = step\n",
    "    \n",
    "    weight_list = np.arange(start, end + step, step)\n",
    "    grid_axes = [(w1, w2) for w1 in weight_list for w2 in weight_list]\n",
    "    w1_values, w2_values = zip(*grid_axes)\n",
    "\n",
    "    loss_values = list(z[sigfrac, m1, m2])\n",
    "    min_loss = min(loss_values)\n",
    "    max_loss = max(loss_values)\n",
    "    normalized_loss = [(x - min_loss) / (max_loss - min_loss) for x in loss_values]\n",
    "    bins = int(np.sqrt(len(z[sigfrac, m1, m2])))\n",
    "\n",
    "    star1_coords = (m1, m2)\n",
    "    star2_coords = (m2, m1)\n",
    "\n",
    "    plt.figure(figsize=(8, 6))\n",
    "    h = plt.hist2d(w1_values, w2_values, bins=(bins, bins), cmap='viridis', weights=normalized_loss)\n",
    "    plt.scatter(*star1_coords, c='red', marker='*', s=200, label='Star 1')\n",
    "    plt.scatter(*star2_coords, c='blue', marker='*', s=200, label='Star 2')\n",
    "    plt.colorbar(label='Loss (BCE)')\n",
    "    plt.xlabel('m1')\n",
    "    plt.ylabel('m2')\n",
    "    plt.title('6 Features (m1 = {} | m2 = {}) sigfrac: {:.4f}'.format(m1, m2, sigfrac))\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "    \n",
    "    return h\n",
    "loss_landscape_nofit(0.001, 3, 3, z_allm1m2_6HD);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "317f864a-91cc-4541-9383-ad020e96f88a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def loss_landscape_2D(sigfrac, m1, m2, w1_out, w2_out, z):\n",
    "    m1_values, m2_values = zip(*grid_axes.keys())\n",
    "\n",
    "    loss_values = list(z[sigfrac, m1, m2])\n",
    "    min_loss = min(loss_values)\n",
    "    max_loss = max(loss_values)\n",
    "\n",
    "    star1_coords = (m1, m2)  \n",
    "    star2_coords = (m2, m1)\n",
    "    fitoutput_coords = (w1_out, w2_out)\n",
    "\n",
    "    normalized_loss = [(x - min_loss) / (max_loss - min_loss) for x in loss_values]\n",
    "    \n",
    "    h = plt.hist2d(m1_values, m2_values, bins=(12, 12), cmap='viridis', weights=normalized_loss)\n",
    "    plt.scatter(*star1_coords, c='red', marker='*', s=200, label='Star 1')\n",
    "    plt.scatter(*star2_coords, c='blue', marker='*', s=200, label='Star 2')\n",
    "    plt.scatter(*fitoutput_coords, c='black', marker='.', s=200, label='fit_output')\n",
    "    plt.colorbar(label='Loss (BCE)')\n",
    "\n",
    "    plt.xlabel('m1')\n",
    "    plt.ylabel('m2')\n",
    "    plt.title('(m1 = {} | m2 = {}) sigfrac: {:.4f}'.format(m1, m2, sigfrac))\n",
    "    return h\n",
    "\n",
    "loss_landscape_2D(sig_space[5], 3, 3, 6, 6, z);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "59fdbb49-5394-42a1-8ae8-891d18a2a33f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x600 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "from matplotlib.gridspec import GridSpec\n",
    "\n",
    "sigspace = np.logspace(-3.5, -1.3, 10)\n",
    "sigfrac = sigspace[4]\n",
    "decay = \"qqq\"\n",
    "m1, m2 = 1, 5\n",
    "m1_2, m2_2 = 3, 3\n",
    "z1 = np.load(\"data/landscapes/z_6_4_15_0.5_qqq_extra_23prong_fixedNEW_False.npy\", allow_pickle = True).item()\n",
    "z2 = np.load(\"data/landscapes/z_6_4_33_0.5_qqq_extra_23prong_fixedNEW_False.npy\", allow_pickle = True).item()\n",
    "sigspace = np.logspace(-3.5, -1.3, 10)\n",
    "save = False\n",
    "\n",
    "start = 0.5\n",
    "end = 6\n",
    "step = 0.5\n",
    "\n",
    "weight_list = np.arange(start, end + step, step)\n",
    "\n",
    "x_values = weight_list\n",
    "y_values = weight_list\n",
    "\n",
    "x, y = np.meshgrid(x_values, y_values)\n",
    "\n",
    "loss_values_flat = z1[sigfrac, m1, m2, decay]\n",
    "loss_values = np.transpose(np.array(loss_values_flat).reshape(x.shape))\n",
    "\n",
    "interp_spline = RectBivariateSpline(x_values, y_values, loss_values, s = 0)\n",
    "\n",
    "xi, yi = np.meshgrid(np.linspace(min(x_values), max(x_values), 1000), np.linspace(min(y_values), max(y_values), 1000))\n",
    "zi = interp_spline(xi[0, :], yi[:, 0])\n",
    "\n",
    "loss_values_flat2 = z2[sigfrac, m1_2, m2_2, decay]\n",
    "loss_values2 = np.transpose(np.array(loss_values_flat2).reshape(x.shape))\n",
    "\n",
    "interp_spline2 = RectBivariateSpline(x_values, y_values, loss_values2, s = 0)\n",
    "\n",
    "xi2, yi2 = np.meshgrid(np.linspace(min(x_values), max(x_values), 1000), np.linspace(min(y_values), max(y_values), 1000))\n",
    "zi2 = interp_spline2(xi2[0, :], yi2[:, 0])\n",
    "\n",
    "#2d projection\n",
    "fig = plt.figure(figsize=(16, 6))\n",
    "gs = GridSpec(1, 2, figure=fig)\n",
    "colors = [(1, 0, 0), (1, 1, 1)]\n",
    "\n",
    "cmap = LinearSegmentedColormap.from_list('blue_white', colors)  \n",
    "#cmap = \"viridis\"\n",
    "\n",
    "fontsize = 13\n",
    "levels = 15\n",
    "zoffset = (zi - np.log(2)) * 1000000\n",
    "zoffset2 = (zi2 - np.log(2)) * 1000000\n",
    "\n",
    "ax0 = fig.add_subplot(gs[0, 0])\n",
    "h1 = ax0.contourf(xi, yi, zoffset, cmap=cmap, levels=levels)\n",
    "ax0.set_aspect(\"equal\")\n",
    "ax0.set_title(f\"$m_X = {m1*100}$ GeV $\\quad m_Y = {m2*100}$ GeV\" + f\"$\\quad \\\\mu$ = {sigfrac * 100:.2f} %\", fontsize=fontsize)\n",
    "ax0.set_xlabel(r\"$m_{X}$\", fontsize=fontsize)\n",
    "ax0.set_ylabel(r\"$m_{Y}$\", fontsize=fontsize)\n",
    "ax0.tick_params(axis='x', labelsize=fontsize)\n",
    "ax0.tick_params(axis='y', labelsize=fontsize)\n",
    "\n",
    "for spine in ax0.spines.values():\n",
    "    spine.set_linewidth(0.5)\n",
    "\n",
    "ax1 = fig.add_subplot(gs[0, 1])\n",
    "h2 = ax1.contourf(xi2, yi2, zoffset2, cmap=cmap, levels=levels)\n",
    "ax1.set_aspect(\"equal\")\n",
    "ax1.set_title(f\"$m_X = {m1_2*100}$ GeV $\\quad m_Y = {m2_2*100}$ GeV\" + f\"$\\quad \\\\mu$ = {sigfrac * 100:.2f} %\", fontsize=fontsize)\n",
    "ax1.set_xlabel(r\"$m_{X}$\", fontsize=fontsize)\n",
    "ax1.set_ylabel(r\"$m_{Y}$\", fontsize=fontsize)\n",
    "ax1.tick_params(axis='x', labelsize=fontsize)\n",
    "ax1.tick_params(axis='y', labelsize=fontsize)\n",
    "\n",
    "for spine in ax1.spines.values():\n",
    "    spine.set_linewidth(0.5)\n",
    "\n",
    "cbar = fig.colorbar(h1, ax=[ax0, ax1], location='right', shrink=1)\n",
    "cbar.set_label('Loss', fontsize=fontsize)\n",
    "cbar.ax.tick_params(labelsize=fontsize)\n",
    "\n",
    "for spine in cbar.ax.spines.values():\n",
    "    spine.set_linewidth(0.5)\n",
    "\n",
    "if save == True:\n",
    "    plt.savefig(f'plots/losslandscapes_{sigfrac:.4f}transposed.pdf', dpi=450, bbox_inches='tight', format='pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a32202e2-12a2-4272-9ec9-ab18dd95a4f9",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def animate(sigfrac, m1, m2, w1, w2, epochs, z):\n",
    "    for key, value in train_wsmodel(sigfrac, m1, m2, w1, w2, epochs).items():\n",
    "        w1_fit_coord = value[0]\n",
    "        w2_fit_coord = value[1]\n",
    "\n",
    "        plt.figure()\n",
    "        loss_landscape(sigfrac, m1, m2, w1_fit_coord, w2_fit_coord, z)\n",
    "        plt.show()\n",
    "        clear_output(wait=True)\n",
    "        \n",
    "    loss_landscape(sigfrac, m1, m2, w1_fit_coord, w2_fit_coord, z)\n",
    "    print(\"Final weight coordinates: w1 = {} \".format(w1_fit_coord) + \" w2 = {} \".format(w2_fit_coord))\n",
    "        \n",
    "sigfrac = sig_list[19]\n",
    "w1, w2 = 2, 3\n",
    "m1, m2 = 3, 4.5\n",
    "epochs = 50\n",
    "animate(sigfrac, m1, m2, w1, w2, epochs, z345)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ea2ef3f9-ef65-426d-b562-80d539a6f443",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def animate_random(sigfrac, m1,m2, w1, w2, epochs, z):\n",
    "    print(f\"Initial Weights: {w1} {w2}\")\n",
    "    animate(sigfrac, m1, m2, w1, w2, epochs, z)\n",
    "    \n",
    "sigfrac = 0.05\n",
    "random_number1 = random.uniform(0.1, 6.0)\n",
    "random_number2 = random.uniform(0.1, 6.0)\n",
    "m1, m2 = 1, 5.5\n",
    "epochs = 50\n",
    "\n",
    "animate_random(sigfrac, m1,m2, random_number1, random_number2, 50, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "4e84a66e-a8c4-4742-923b-172a2139231e",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#save images to make them gifs\n",
    "def create_gif_fitout(sigfrac, m1, m2, w1, w2, z, epochs):\n",
    "    output_directory = '2dhist_images'\n",
    "    os.makedirs(output_directory, exist_ok=True)\n",
    "\n",
    "    for key, value in train_wsmodel(sigfrac, m1, m2, w1, w2, epochs).items():\n",
    "        w1_fit_coord = value[0]\n",
    "        w2_fit_coord = value[1]\n",
    "\n",
    "        loss_landscape_2D(sigfrac, m1, m2, w1_fit_coord, w2_fit_coord, z)\n",
    "\n",
    "        image_path = os.path.join(output_directory, f'hist_{key}.png')\n",
    "        plt.savefig(image_path)\n",
    "        plt.close()\n",
    "\n",
    "        clear_output(wait=True)\n",
    "        \n",
    "    #make the gif\n",
    "    frames = []\n",
    "\n",
    "    image_dir = '2dhist_images'\n",
    "    image_files = os.listdir(image_dir)\n",
    "\n",
    "    image_files = sorted([filename for filename in os.listdir(image_dir) if filename.endswith('.png')], key=lambda x: int(x.split('_')[1].split('.')[0]))\n",
    "    for filename in image_files:\n",
    "        image = Image.open(os.path.join(image_dir, filename))\n",
    "        frames.append(image)\n",
    "        os.remove(image_dir+\"/\"+filename)\n",
    "\n",
    "    output_gif_filename = f'{sigfrac, m1, m2, w1, w2}.gif'\n",
    "    frames[0].save(output_gif_filename, save_all=True, append_images=frames[1:], duration=200, loop=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "id": "04c933b5-499d-4043-9462-ce219f95a8ad",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.736706332731714 3.002639396491747\n",
      "Signal Fraction:  0.011288378916846888\n",
      "30/30 [==============================] - 1s 15ms/step - loss: 0.6926 - val_loss: 0.6926\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6923 - val_loss: 0.6923\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6921 - val_loss: 0.6920\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6919 - val_loss: 0.6917\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 1s 22ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 8ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 8ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6917 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 8ms/step - loss: 0.6917 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "30/30 [==============================] - 1s 26ms/step - loss: 0.6917 - val_loss: 0.6916\n",
      "30/30 [==============================] - 0s 7ms/step - loss: 0.6916 - val_loss: 0.6915\n",
      "3 4.5 4.562472 2.8867893\n"
     ]
    }
   ],
   "source": [
    "w1 = random.uniform(0.5, 6.0)\n",
    "w2 = random.uniform(0.5, 6.0)\n",
    "\n",
    "print(w1, w2)\n",
    "sigfrac = sig_space[10]\n",
    "m1 = 3\n",
    "m2 = 4.5\n",
    "epochs = 50\n",
    "create_gif_fitout(sigfrac, m1, m2, w1, w2, z_allm1m2, epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "967e5087-8647-45ba-9fd7-4396ddd6364d",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "sig_space = np.logspace(-3, -1, 20)\n",
    "for sigfrac in sig_space:\n",
    "    m1, m2 = 1, 5.5\n",
    "    w1 = round(random.uniform(0.5, 6.0),3)\n",
    "    w2 = round(random.uniform(0.5, 6.0),3)\n",
    "    epochs = 50\n",
    "    frames = create_gif_fitout(sigfrac, m1, m2, w1, w2, z_allm1m2, epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "72febea8-49ad-47ff-9703-245bd1efd205",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def create_gif_nofit(m1, m2, z):\n",
    "    \n",
    "    output_directory = '2dhist_images'\n",
    "    os.makedirs(output_directory, exist_ok=True)\n",
    "    \n",
    "    sig_space = np.logspace(-3, -1 , 20)\n",
    "    \n",
    "    frames = []\n",
    "    for sb in sig_space:\n",
    "    \n",
    "        loss_landscape_nofit(sb, m1, m2, z)\n",
    "\n",
    "        image_path = os.path.join(output_directory, f'hist_{sb}.png')\n",
    "        plt.savefig(image_path)\n",
    "        plt.close()\n",
    "        clear_output(wait=True)\n",
    "\n",
    "        frames.append(Image.open(image_path))\n",
    "\n",
    "    output_gif_filename = f'sigspace{m1}{m2}fixed.gif'\n",
    "    frames[0].save(output_gif_filename, save_all=True, append_images=frames[1:], duration=400, loop=0)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tensorflow-2.9.0",
   "language": "python",
   "name": "tensorflow-2.9.0"
  },
  "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.9.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}