From e52e6754499277359b7272cd3a496851a8b71a6c Mon Sep 17 00:00:00 2001 From: Pietro Rodolfo Masera Date: Fri, 9 Jun 2023 17:30:33 +0200 Subject: [PATCH] Presentation notebook added --- presentation_notebook.ipynb | 281 +++++++++++++++++++++++++++++------- 1 file changed, 227 insertions(+), 54 deletions(-) diff --git a/presentation_notebook.ipynb b/presentation_notebook.ipynb index cb9bc73..72f7220 100644 --- a/presentation_notebook.ipynb +++ b/presentation_notebook.ipynb @@ -1,94 +1,253 @@ { "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import ipywidgets as widgets\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import math\n", + "import pandas as pd \n", + "from IPython.display import Image, display\n", + "\n", + "#Newest_York = r'Newest_York.png'\n", + "\n", + "#display(Image(filename=Newest_York, width=700, height=500))" + ] + }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ - "

Function for getting scores: Sigmoid fucntion

" + "

I + II) Function for getting Estimated Growth & Past Performance Scores --> Sigmoid fucntion

" ] }, { "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "75.50813375962909\n" - ] - } - ], - "source": [ - "\n", - "mean_stocks = 5\n", - "value_stock = 4\n", - "\n", - "score= (200/(1+math.e**( 0.5*(mean_stocks-value_stock))))\n", - "\n", - "print(score)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "fdff635633274867ae895d1cab7491e8", + "version_major": 2, + "version_minor": 0 + }, "text/plain": [ - "
" + "interactive(children=(FloatSlider(value=6.6164130434782615, description='x', max=200.0, min=-200.0, step=1.0),…" ] }, "metadata": {}, "output_type": "display_data" }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "\n", + "\n", + "not_normalized = pd.read_csv('Elaborated_Data/Not_Normalized.csv')\n", + "\n", + "\n", + "\n", + "\n", + "average_score = not_normalized['Estimated Growth'].str.rstrip('%').astype(float).mean() #STARTING POINT (Analyt's yearly estimated growth (%) for next 5 years)\n", + "\n", + "slope = 0.1\n", + "\n", + "def plot_function(x):\n", + " y = (200 / (1 + math.e**(-slope * (-average_score + x))))\n", + " plt.plot(x_values, y_values)\n", + " plt.scatter(x, y, color='red', label=f'x={x}')\n", + " plt.xlabel('Estimated Growth (yearly in %)')\n", + " plt.ylabel('Stockingly Score')\n", + " plt.title('Estimated growth Score = sigmoid(Estimated growth %)')\n", + " plt.legend()\n", + " plt.grid(False) \n", + " plt.axhline(0, color='black') \n", + " plt.axvline(0, color='black') \n", + "\n", + " plt.axhline(y, color='green') \n", + "\n", + " plt.xlim(-200, 200) \n", + " plt.ylim(-10, 250) \n", + "\n", + " plt.show()\n", + "\n", + "# Generate x values from -100 to 100\n", + "x_values = np.linspace(-200, 200, 200)\n", + "y_values = (200 / (1 + np.exp(-slope * (-average_score + x_values))))\n", + "\n", + "widgets.interact(plot_function, x=widgets.FloatSlider(min=-200, max=200, step=1, value=average_score))\n", + "\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

III) Function for getting Financial health --> score: reverse exponential

" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1e6dab8358774ba1b4a796b47bbf6360", + "model_id": "af5a85302f68434687bbd8facf8f752c", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(IntSlider(value=1, description='w', max=10), FloatSlider(value=1.0, description='amp', m…" + "interactive(children=(FloatSlider(value=4.970859020630443, description='x', max=50.0, step=0.5), Output()), _d…" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "import ipywidgets as widgets\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "# set up plot\n", - "fig, ax = plt.subplots(figsize=(6, 4))\n", - "ax.set_ylim([-4, 4])\n", - "ax.grid(True)\n", - " \n", - "# generate x values\n", - "x = np.linspace(0, 2 * np.pi, 100)\n", - " \n", - " \n", - "def my_sine(x, w, amp, phi):\n", - " \"\"\"\n", - " Return a sine for x with angular frequeny w and amplitude amp.\n", - " \"\"\"\n", - " return amp*np.sin(w * (x-phi))\n", - " \n", - " \n", - "@widgets.interact(w=(0, 10, 1), amp=(0, 4, .1), phi=(0, 2*np.pi+0.01, 0.01))\n", - "def update(w = 1.0, amp=1, phi=0):\n", - " \"\"\"Remove old lines from plot and plot new one\"\"\"\n", - " [l.remove() for l in ax.lines]\n", - " ax.plot(x, my_sine(x, w, amp, phi), color='C0')\n", + "import sys\n", + "sys.path.append('../group-1')\n", + "import math\n", + "import pandas as pd\n", + "import numpy as np \n", + "\n", + "not_normalized = pd.read_csv('Elaborated_Data/Not_Normalized.csv')\n", + "\n", + "\n", + "average_score = not_normalized['Financial Health'].mean() #STARTING POINT (Mean Assets/debts)\n", + "\n", + "\n", + "slope = 0.1\n", + "\n", + "def plot_function(x):\n", + " y = 200 - 200*math.e**(-0.138 * (x))\n", + " plt.plot(x_values, y_values)\n", + " plt.scatter(x, y, color='red', label=f'x={x}')\n", + " plt.xlabel('Total Assets/Total Debt')\n", + " plt.ylabel('Stockingly Score')\n", + " plt.title('Financial Health Score = ReverseExp(TOT Assets/TOT Debts)')\n", + " plt.legend()\n", + " plt.grid(False) \n", + " plt.axhline(0, color='black') \n", + " plt.axvline(0, color='black') \n", + " plt.axhline(y, color='blue') \n", + " plt.xlim(0, 100) \n", + " plt.ylim(-10, 250) \n", + " plt.show()\n", + "\n", + "x_values = np.linspace(-200, 200, 200)\n", + "y_values = 200 - 200*math.e**(-0.138 * (x_values))\n", + "\n", + "\n", + "widgets.interact(plot_function, x=widgets.FloatSlider(min=0, max=50, step=0.5, value=average_score))\n", "\n" ] }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "

IV) Function for getting valuation$ score from PEG: -->Custom Fractal

" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "408bf7513fd64524b52b357aeac197ea", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=2.794997826086956, description='x', max=30.0), Output()), _dom_classes…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import sys\n", + "sys.path.append('../group-1')\n", + "import math\n", + "import pandas as pd\n", + "import numpy as np \n", + "\n", + "not_normalized = pd.read_csv('Elaborated_Data/Not_Normalized.csv')\n", + "\n", + "average_score = not_normalized['Valuation'].mean() #STARTING POINT (MEAN PEG RATIO)\n", + "\n", + "\n", + "\n", + "\n", + "def plot_function(x):\n", + " y = (200/(1+(1/9*x**2)))\n", + " plt.plot(x_values, y_values)\n", + " plt.scatter(x, y, color='red', label=f'x={x}')\n", + " plt.xlabel('PEG value')\n", + " plt.ylabel('Stockingly Score Valuation')\n", + " plt.title('Valuation Score = FractalPolynomial(PEG)')\n", + " plt.legend()\n", + " plt.grid(False) \n", + " plt.axhline(0, color='black') \n", + " plt.axvline(0, color='black') \n", + " plt.axhline(y, color='blue') \n", + " plt.xlim(0, 100) \n", + " plt.ylim(-10, 250) \n", + " plt.show()\n", + "\n", + "x_values = np.linspace(0, 200, 2000)\n", + "\n", + "y_values = (200/(1+(1/9*x_values**2)))\n", + "\n", + "widgets.interact(plot_function, x=widgets.FloatSlider(min=0, max=30, step=0.1, value=average_score))\n" + ] + }, { "cell_type": "code", "execution_count": null, @@ -98,8 +257,22 @@ } ], "metadata": { + "kernelspec": { + "display_name": "visual-analytics", + "language": "python", + "name": "python3" + }, "language_info": { - "name": "python" + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" }, "orig_nbformat": 4 },