Nuclear_Binding_Fitting.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Nuclear Binding Fitting.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/edwinsolisf/MLNuclearBindingEnergy/blob/master/Nuclear_Binding_Fitting.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "First, we import the utilities and common machine learning libraries:\n",
        "  - Panda: used for reading the CSV files\n",
        "  - Numpy: used for fast math operations\n",
        "  - Sklearn: used for the linear and polynomial regression as well as data separation\n",
        "  - Scipy: used for the optimization algorithms:\n",
        "  - Matplotlib: used to display graphs for the outputs\n",
        "\n",
        "\n",
        "These are all common and important imports when performing machine learning"
      ],
      "metadata": {
        "id": "53IZrd7LXMah"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "import csv\n",
        "from mendeleev import element\n",
        "from google.colab import files\n",
        "from sklearn.linear_model import LinearRegression\n",
        "from sklearn.preprocessing import PolynomialFeatures\n",
        "from sklearn.pipeline import make_pipeline\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.metrics import mean_squared_error\n",
        "import plotly.express as px\n",
        "\n",
        "from scipy.optimize import minimize"
      ],
      "metadata": {
        "id": "DmQmVSlIPqQ7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "To obtain the data, we can fetch the periodic table of elements from the web. Then we generated our own csv file that included the binding energies as calculated with $E = mc^2$. From the csv (which was orginally generated in a seperate python documentation) we generated a list of tuples with the number of protons, number of nucleons (protons + nucleons), and the binding energy of the isotope. "
      ],
      "metadata": {
        "id": "e87nYA9sbA2k"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Form an array of binding energies using B = c^2 * (Atom mass - Sum of Nucleon Masses)\n",
        "#Masses in GeV\n",
        "pMass = 0.938\n",
        "nMass = 0.939\n",
        "GeVPerAmu = 0.931\n",
        "\n",
        "isoarray = []\n",
        "for i in range(118):\n",
        "  i += 1\n",
        "  elem = element(i)\n",
        "  for iso in elem.isotopes:\n",
        "    bindEnergy = (iso.atomic_number * pMass) + (iso.mass_number - iso.atomic_number)*nMass - iso.mass_number * GeVPerAmu\n",
        "    isoarray.append([iso.atomic_number,iso.mass_number, iso.mass, bindEnergy, iso.is_radioactive])\n",
        "\n",
        "out = pd.DataFrame(isoarray, columns = ['Proton Number','Nucleon Number','Mass', 'Binding Energy', 'Is Unstable'])\n",
        "#out.to_csv(\"BindingEnergy.csv\") "
      ],
      "metadata": {
        "id": "ZwoqHYF-PTbG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_periodic_table():\n",
        "    url = \"https://raw.githubusercontent.com/CorbinDPacheco/prog/main/Periodic%20Table%20of%20Elements.csv\"\n",
        "    periodic_table_csv = pd.read_csv(url)\n",
        "    symbol_table = periodic_table_csv['Symbol']\n",
        "    periodic_table = {}\n",
        "\n",
        "    for i in range(len(periodic_table_csv['AtomicNumber'])):\n",
        "        periodic_table[symbol_table[i].strip()] = i + 1\n",
        "\n",
        "    return periodic_table"
      ],
      "metadata": {
        "id": "dg2S8xJ-QBIi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def get_binding_table():\n",
        "    '''\n",
        "    Returns a list with tuples of the Proton Number, Nucleon Number, and Binding Energy in that order\n",
        "    '''\n",
        "    url = \"https://raw.githubusercontent.com/CorbinDPacheco/prog/main/OGBindingEnergy.csv\"\n",
        "    isotope_table_csv = pd.read_csv(url)\n",
        "    isotope_table = []\n",
        "\n",
        "    for i in range(len(isotope_table_csv['Proton Number'])):\n",
        "        isotope_table.append((isotope_table_csv['Proton Number'][i], isotope_table_csv['Nucleon Number'][i], isotope_table_csv['Binding Energy'][i] * 1000))\n",
        "\n",
        "    return isotope_table"
      ],
      "metadata": {
        "id": "zzx6RJRyQnvr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "For the first model, we will try to fit a polynomial to the nuclear binding energy of the isotopes and try to obtain a good relationship for the data.\n",
        "From the theoretical model given by the semi-empirical formula, we can try to take advantage of its mathematical structure to have a better model.\n",
        "\n",
        "If we note that most of the non-integer order term are fractional with a cube root in them, we can see that a fit against a cube root of the nucleon terms will give us a polynomial-like equation with the biggest term being at most 3 for the nucleons and 2 for the protons. Hence, we can first try to use a third-degree polynomial for this."
      ],
      "metadata": {
        "id": "1bVrVMdFboGY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def binding_regression():\n",
        "    '''\n",
        "    Fitting binding energy to a 3rd degree polynomial using linear regression \n",
        "    '''\n",
        "    table = get_binding_table()\n",
        "\n",
        "    X = []\n",
        "    Y = []\n",
        "    for elem in table:\n",
        "        X.append([elem[0], elem[1] ** (1./3.)])\n",
        "        Y.append(elem[2])\n",
        "\n",
        "    X = np.array(X)\n",
        "    Y = np.array(Y)\n",
        "\n",
        "    X_train, x_test, Y_train, y_test = train_test_split(X, Y, test_size=0.1, random_state=0)\n",
        "\n",
        "    pipeline = make_pipeline(PolynomialFeatures(3), LinearRegression())\n",
        "    pipeline.fit(X_train, Y_train)\n",
        "\n",
        "    print(\"Intercept: \", pipeline.named_steps['linearregression'].intercept_)\n",
        "    print(\"Coefficients \", pipeline.named_steps['linearregression'].coef_)\n",
        "    print(pipeline.named_steps['polynomialfeatures'].powers_)\n",
        "    print(\"Regression r-score: \", pipeline.score(x_test, y_test))\n",
        "\n",
        "    x_test_nucleons = []\n",
        "    for pair in x_test:\n",
        "        x_test_nucleons.append(pair[1] ** 3.)\n",
        "\n",
        "    figure, axis = plt.subplots(2)\n",
        "\n",
        "    axis[0].scatter(x_test_nucleons, y_test, s=2, label = \"True Values\")\n",
        "    axis[0].scatter(x_test_nucleons, pipeline.predict(x_test), s=1, label = \"Predicted Values\")\n",
        "    axis[0].legend()\n",
        "    axis[0].set_title(\"Binding Energy fit with 3rd degree Polynomial\")\n",
        "    axis[0].set_xlabel(\"Number of Nucleons\")\n",
        "    axis[0].set_ylabel(\"Binding Energy (MeV)\")\n",
        "\n",
        "    axis[1].scatter(x_test_nucleons, y_test / x_test_nucleons, s=2)\n",
        "    axis[1].scatter(x_test_nucleons, pipeline.predict(x_test) / x_test_nucleons, s=1)\n",
        "    axis[1].set_title(\"Binding Energy per Nucleon fit with 3rd degree Polynomial\")\n",
        "    axis[1].set_xlabel(\"Number of Nucleons\")\n",
        "    axis[1].set_ylabel(\"Binding Energy per nucelon (MeV/#num)\")\n",
        "    plt.subplots_adjust(hspace=0.7)\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "LAW8DaMzQiOb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "In this first model we note that near the smaller isotopes the graph for the nuclear binding energy per nucleon fails significantly to predict the correct values.\n",
        "\n",
        "Therefore, for our second model, we can try an improve this by fiting the nuclear binding energy per nucleon instead of the regular binding energy.\n",
        "For this one, again, using the theoretical prediction of the semi-empirical formula we can obtain a shape for this quantity and we can try the same trick as the previous model: fit against the cube root of the number of nucleons."
      ],
      "metadata": {
        "id": "7-7hjiSMdLHw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def binding_per_nucleon_regression():\n",
        "    '''\n",
        "    Fitting binding energy per nucleon to a 5th degree polynomial using linear regression \n",
        "    '''\n",
        "    table = get_binding_table()\n",
        "\n",
        "    X = []\n",
        "    Y = []\n",
        "    for elem in table:\n",
        "        X.append([elem[0], elem[1] ** (1./3.)])\n",
        "        Y.append(elem[2] * elem[1] ** (1./3.))\n",
        "\n",
        "    X = np.array(X)\n",
        "    Y = np.array(Y)\n",
        "\n",
        "    X_train, x_test, Y_train, y_test = train_test_split(X, Y, test_size=0.1, random_state=0)\n",
        "\n",
        "    pipeline = make_pipeline(PolynomialFeatures(5), LinearRegression())\n",
        "    pipeline.fit(X_train, Y_train)\n",
        "\n",
        "    nucleons = []\n",
        "    binding = Y_train\n",
        "    predict_binding = pipeline.predict(X_train)\n",
        "    binding_per_nucleon = []\n",
        "    predict_binding_per_nucleon = []\n",
        "    for i in range(len(X_train)):\n",
        "        nucleons.append(X_train[i][1] ** 3.)\n",
        "        predict_binding[i] = predict_binding[i] / nucleons[i] ** (1./3.)\n",
        "        Y_train[i] = Y_train[i] / nucleons[i] ** (1./3.)\n",
        "        binding_per_nucleon.append(Y_train[i] / nucleons[i])\n",
        "        predict_binding_per_nucleon.append(predict_binding[i] / nucleons[i])\n",
        "\n",
        "    print(\"Intercept: \", pipeline.named_steps['linearregression'].intercept_)\n",
        "    coeff = pipeline.named_steps['linearregression'].coef_\n",
        "    powers = pipeline.named_steps['polynomialfeatures'].powers_\n",
        "\n",
        "    for i in range(len(coeff)):\n",
        "        print(powers[i], coeff[i])\n",
        "    print(\"Regression r-score: \", pipeline.score(x_test, y_test))\n",
        "\n",
        "    fig, ax = plt.subplots(2)\n",
        "\n",
        "    ax[0].scatter(nucleons, binding, s=2, label = \"True Values\")\n",
        "    ax[0].scatter(nucleons, predict_binding, s=1, label = \"Predicted Values\")\n",
        "    ax[0].legend()\n",
        "    ax[0].set_title(\"Binding Energy fit with 5th degree Polynomial\")\n",
        "    ax[0].set_xlabel(\"Number of Nucleons\")\n",
        "    ax[0].set_ylabel(\"Binding Energy (MeV)\")\n",
        "  \n",
        "    ax[1].scatter(nucleons, binding_per_nucleon, s=2)\n",
        "    ax[1].scatter(nucleons, predict_binding_per_nucleon, s=1)\n",
        "    ax[1].set_title(\"Binding Energy per nucleon fit with 5th degree Polynomial\")\n",
        "    ax[1].set_xlabel(\"Number of Nucleons\")\n",
        "    ax[1].set_ylabel(\"Binding Energy per nucelon (MeV/#num)\")\n",
        "    plt.subplots_adjust(hspace=0.7)\n",
        "    plt.show()"
      ],
      "metadata": {
        "id": "n3YYAAznR6V4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finally, for the last models, we actually try to fit the data to the actual semi-empirical formula and obtain the coefficients for this equation.\n",
        "\n",
        "To do this, we can try using optimization of parameters by minimizing the difference between the experimental binding energy and the theoretical predicted by the equation. By transforming this to a matrix-vector multiplication problem, if we form a matrix with the evaluated terms from the isotope data, and use the binding energy data as the output vector, we can try and find the input vector that will produce with least error the output vector with the matrix-vector multiplication. This way, we will find the coefficients that best fit the data and the semi-empirical formula.\n",
        "\n",
        "For this case, we will use a quadratic error formula as the cost function, and use the local optimizer `SLSQP`."
      ],
      "metadata": {
        "id": "fmjyw2uTd__P"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "GzELZaRfRiM0"
      },
      "outputs": [],
      "source": [
        "def binding_optimization():\n",
        "    '''\n",
        "    Fitting the coefficients of the semi-empirical formula\n",
        "    '''\n",
        "    table = get_binding_table()\n",
        "\n",
        "    binding = []\n",
        "    nucleons = []\n",
        "    protons = []\n",
        "\n",
        "    for elem in table:\n",
        "        protons.append(elem[0])\n",
        "        nucleons.append(elem[1])\n",
        "        binding.append(elem[2])\n",
        "\n",
        "    binding = np.array(binding)\n",
        "    nucleons = np.array(nucleons)\n",
        "    protons = np.array(protons)\n",
        "\n",
        "    matrix = np.array([nucleons])\n",
        "    matrix = np.concatenate((matrix, np.array([nucleons ** (2./3.)])), axis=0)\n",
        "    matrix = np.concatenate((matrix, np.array([(nucleons ** (-1./3.)) * protons * (protons - 1)])), axis=0)\n",
        "    matrix = np.concatenate((matrix, np.array([((nucleons - protons * 2) ** 2) / nucleons])), axis=0)\n",
        "    pairing = nucleons ** (-3./4.)\n",
        "    for i in range(len(pairing)):\n",
        "        if nucleons[i] % 2 == 0 and int(protons[i]) % 2 == 1:\n",
        "            pairing[i] = -pairing[i]\n",
        "        elif nucleons[i] % 2 == 0:\n",
        "            continue\n",
        "        else:\n",
        "            pairing[i] = 0\n",
        "    matrix = np.concatenate((matrix, [pairing]), axis=0)\n",
        "    matrix = np.ndarray.transpose(matrix)\n",
        "\n",
        "    initial = np.random.rand(5) * 25\n",
        "    temp = np.matmul(matrix, initial)\n",
        "\n",
        "    def square_error(x):\n",
        "        t = np.matmul(matrix, x)\n",
        "        return np.sum((t - binding) ** 2)\n",
        "\n",
        "    options={'eps': 1.49e-8, 'maxiter': 100000, 'disp': False, 'ftol': 0.0002}\n",
        "    val = minimize(square_error, initial, method='SLSQP', options=options)\n",
        "    params = val.x\n",
        "    print(params)\n",
        "\n",
        "    predict_binding = np.matmul(matrix, params)\n",
        "    binding_per_nucleon = binding / nucleons\n",
        "    predict_binding_per_nucleon = predict_binding / nucleons\n",
        "\n",
        "    fig, ax = plt.subplots(2)\n",
        "\n",
        "    ax[0].scatter(nucleons, binding, s=2, label = \"True Values\")\n",
        "    ax[0].scatter(nucleons, predict_binding, s=1, label = \"Predicted Values\")\n",
        "    ax[0].legend()\n",
        "    ax[0].set_title(\"Binding Energy fit based on Semi-Empirical Formula\")\n",
        "    ax[0].set_xlabel(\"Number of Nucleons\")\n",
        "    ax[0].set_ylabel(\"Binding Energy (MeV)\")\n",
        "  \n",
        "    ax[1].scatter(nucleons, binding_per_nucleon, s=2)\n",
        "    ax[1].scatter(nucleons, predict_binding_per_nucleon, s=1)\n",
        "    ax[1].set_title(\"Binding Energy per nucleon fit based on Semi-Empirical Formula\")\n",
        "    ax[1].set_xlabel(\"Number of Nucleons\")\n",
        "    ax[1].set_ylabel(\"Binding Energy per nucelon (MeV)\")\n",
        "\n",
        "    plt.subplots_adjust(hspace=0.7)\n",
        "    plt.show()\n",
        "\n",
        "    #Heatmaps \n",
        "    heatmap_data = pd.DataFrame()\n",
        "    heatmap_data.insert(0, \"Z\", protons)\n",
        "    heatmap_data.insert(1, \"N\", nucleons-protons)\n",
        "    heatmap_data.insert(2, \"(E/A) MeV\", binding/nucleons)\n",
        "\n",
        "    heatmap_data_temp = heatmap_data.pivot(\"Z\", \"N\", \"(E/A) MeV\")\n",
        "    heatmap_data_temp.sort_index(level=0, ascending=False, inplace=True)\n",
        "\n",
        "    ax = sns.heatmap(heatmap_data_temp, vmin=-6, vmax=10,cbar_kws={'label': '(E/A) MeV'},xticklabels=20, yticklabels=20, cmap='hsv')\n",
        "    ax.set_title('Binding Energy per Nucleon based on Atomic # and Nuetrons')\n",
        "    plt.show()\n",
        "\n",
        "    heatmap_data.drop(columns = [\"(E/A) MeV\"])\n",
        "    heatmap_data.insert(2, \"Predict (E/A) MeV\",  predict_binding_per_nucleon)\n",
        "    heatmap_data = heatmap_data.pivot(\"Z\", \"N\", \"Predict (E/A) MeV\")\n",
        "    heatmap_data.sort_index(level=0, ascending=False, inplace=True)\n",
        "    ax = sns.heatmap(heatmap_data, vmin=-6, vmax=10,cbar_kws={'label': 'Predicted (E/A) MeV'},xticklabels=20, yticklabels=20, cmap='hsv')\n",
        "    ax.set_title('Predicted Binding Energy per Nucleon based on Atomic # and Nuetrons')\n",
        "    plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Next we explored the errors with different built in regression methods. \n",
        "\n",
        "First we explored scipy's polynomial regression. For this we set it up to follow the form of the semi-empirical binding energy formula to create another prediction for the coeficcents"
      ],
      "metadata": {
        "id": "LwOzgtGZT_1c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "### POLYNOMIAL REGRESSION WITH SCIPY\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from matplotlib import pyplot as plt\n",
        "from scipy.constants import elementary_charge\n",
        "from scipy.optimize import curve_fit\n",
        "import os\n",
        "\n",
        "### READ DATA\n",
        "data = pd.read_csv('https://raw.githubusercontent.com/CorbinDPacheco/prog/main/OGBindingEnergy.csv')\n",
        "data = data[data['Binding Energy'] > 0]\n",
        "data['Nucleon Number'] = data['Nucleon Number'].astype(int)\n",
        "data['Proton Number'] = data['Proton Number'].astype(int)\n",
        "\n",
        "### RETURN EQUATION WITH INPUT PARAMETERS TO FIT TO DATA\n",
        "def semiEmpiricalBindingEnergyFit(X, a_v, a_s, a_c, a_sym, a_p):\n",
        "    A, Z = X\n",
        "    delta = np.array([1 if (A[i] % 2 == 0) and (Z[i] % 2 == 0) else -1 if (A[i] % 2 != 0) else 0 for i in range(len(A))])\n",
        "    binding_energy = a_v*A - a_s*A**(2/3) - a_c*Z*(Z-1)*A**(-1/3) - a_sym*(A-2*Z)**2/A+delta*a_p*A**(-3/4)\n",
        "    return binding_energy\n",
        "    \n",
        "### FIT ABOVE PARAMETERS TO DATA\n",
        "popt, pcov = curve_fit(semiEmpiricalBindingEnergyFit, (data['Nucleon Number'],data['Proton Number']), data['Binding Energy'])\n",
        "print(pcov)\n",
        "popt = popt*1e3   #CONVERT FROM MeV TO keV\n",
        "print(f\"a_v = {popt[0]}\\na_s = {popt[1]}\\na_c = {popt[2]}\\na_sym = {popt[3]}\\na_p = {popt[4]}\")\n",
        "\n",
        "### PLOT PERCENT ERROR WITH SCIPY OPTIMIMAL COEFFICIENTS\n",
        "def semiEmpiricalBindingEnergy(A, Z, a_v, a_s, a_c, a_sym, a_p):\n",
        "    delta = np.array([1 if (A % 2 == 0) and (Z % 2 == 0) else -1 if (A % 2 != 0) else 0])\n",
        "    binding_energy = a_v*A - a_s*A**(2/3) - a_c*Z*(Z-1)*A**(-1/3) - a_sym*(A-2*Z)**2/A+delta*a_p*A**(-3/4)\n",
        "    return binding_energy\n",
        "popt = popt*1e-3\n",
        "err = []\n",
        "for i in range(len(data['Binding Energy'])):\n",
        "  NucNum = np.asarray(data['Nucleon Number'])[i]\n",
        "  ProNum = np.asarray(data['Proton Number'])[i]\n",
        "  bindEnergy = np.asarray(data['Binding Energy'])[i]\n",
        "  error = np.abs((bindEnergy - semiEmpiricalBindingEnergy(NucNum,ProNum,popt[0],popt[1],popt[2],popt[3],popt[4]))/bindEnergy)\n",
        "  err.append(error)\n",
        "err = np.array(err)\n",
        "print(err.shape,NucNum.shape)\n",
        "plt.scatter(data['Nucleon Number'],err,) \n",
        "plt.xlabel('Nucleon Number')\n",
        "plt.ylabel('Percent Error')\n",
        "plt.title('Error with Scipy')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "JEEb08DcU8XA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Then we explored the error with stocastic gradient descent. "
      ],
      "metadata": {
        "id": "LdvExwpJVM1y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "### LINEAR REGRESSION WITH STOCHASTIC GRADIENT DESCENT (SGD)\n",
        "from sklearn.pipeline import make_pipeline\n",
        "from sklearn.preprocessing import StandardScaler\n",
        "from sklearn.linear_model import SGDRegressor\n",
        "### IMPORT DATA\n",
        "DS = pd.read_csv('https://raw.githubusercontent.com/CorbinDPacheco/prog/main/OGBindingEnergy.csv')\n",
        "X0 = DS['Proton Number'].astype('int')\n",
        "X1 = DS['Nucleon Number'].astype('int')\n",
        "y = DS['Binding Energy']\n",
        "\n",
        "### CREATE TWO-COLUMN MATRIX WITH PROTON NUMBER, NUCLEON NUMBER FOR EACH ROW\n",
        "X01 = []\n",
        "for i in range(len(X0)):\n",
        "    X01.append([X0[i],X1[i]])\n",
        "  \n",
        "### CREATE AND FIT PIPELINE TO DATA\n",
        "reg = make_pipeline(StandardScaler(), SGDRegressor(max_iter = 1000, tol = 1e-3))\n",
        "reg.fit(X01,y)\n",
        "reg.predict([[4,12]])\n",
        "\n",
        "\n",
        "### PERCENT ERROR WITH SGD REGRESSION\n",
        "err = []\n",
        "for i in range(len(DS['Binding Energy'])-1):\n",
        "    error = np.abs((DS['Binding Energy'][i+1] - reg.predict([[X0[i+1],X1[i+1]]]))/DS['Binding Energy'][i+1])\n",
        "    err.append(error)\n",
        "err = np.array(err)\n",
        "DS['Nucleon Number'].pop(0)\n",
        "plt.scatter(DS['Nucleon Number'],err) \n",
        "plt.xlabel('Nucleon Number')\n",
        "plt.ylabel('Percent Error')\n",
        "plt.title('Error with SGD')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "zbAdOmLGV3yX"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here we print out the actual results of our algorithm which we have better presented in our powerpoint "
      ],
      "metadata": {
        "id": "6GgmmSaVSKhv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def main():\n",
        "    binding_regression()\n",
        "    binding_per_nucleon_regression()\n",
        "    binding_optimization()\n",
        "\n",
        "\n",
        "if __name__ == '__main__':\n",
        "    main()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "81iThtb5SX5e",
        "outputId": "ac40a031-7512-4755-e120-5b3d119db1b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Intercept:  155.06403739236407\n",
            "Coefficients  [ 0.00000000e+00 -5.90450635e+01 -2.44521493e+02 -8.19434271e-01\n",
            "  2.63140512e+01  1.55510558e+02 -9.87298020e-05  6.96342349e-02\n",
            " -8.67436689e-01 -2.51502221e+01]\n",
            "[[0 0]\n",
            " [1 0]\n",
            " [0 1]\n",
            " [2 0]\n",
            " [1 1]\n",
            " [0 2]\n",
            " [3 0]\n",
            " [2 1]\n",
            " [1 2]\n",
            " [0 3]]\n",
            "Regression r-score:  0.9995577283514738\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Intercept:  38.636642185476376\n",
            "[0 0] 0.0\n",
            "[1 0] 346.5410509605562\n",
            "[0 1] -167.86706634262484\n",
            "[2 0] -2.2160512354649793\n",
            "[1 1] -557.1115679386729\n",
            "[0 2] 8.126993780621444\n",
            "[3 0] 0.23816772180367077\n",
            "[2 1] -11.18976259658182\n",
            "[1 2] 318.1263148787285\n",
            "[0 3] 152.5547588689745\n",
            "[4 0] 0.0019002217866131497\n",
            "[3 1] -0.16546418135438487\n",
            "[2 2] 4.716499871611346\n",
            "[1 3] -62.32145483957317\n",
            "[0 4] -81.41711884243219\n",
            "[5 0] 4.523584243453474e-06\n",
            "[4 1] -0.000555363556458285\n",
            "[3 2] 0.025028607147738136\n",
            "[2 3] -0.493024601195402\n",
            "[1 4] 4.008900576679667\n",
            "[0 5] 9.694670498115654\n",
            "Regression r-score:  0.9999893147987042\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 15.04143779 -16.1310376   -0.68529289 -21.74703673  19.76020526]\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}