Datasets:

---

bigcode

/

jupyter-parsed

like 4

Follow

BigCode 1.35k

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "import sys\nimport time\nimport numpy as np\nimport matplotlib\nmatplotlib.use('nbagg')\nimport matplotlib.pyplot as plt\nfrom astropy import stats, visualization\n\nfrom indiclient.indicam import MATCam, F9WFSCam, CCDCam\nfrom camsrv.camsrv import CAMsrv\n\n%load_ext autoreload\n%autoreload 2", "_____no_output_____" ], [ "s = CAMsrv()", "[I 190311 13:12:18 indiclient:1235] INDISwitchVector: CCD Simulator CONNECTION Connection SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: CONNECT Connect Switch On\n[I 190311 13:12:18 indiclient:580] INDIElement: DISCONNECT Disconnect Switch Off\n[I 190311 13:12:18 indiclient:1104] INDIVector: CCD Simulator DRIVER_INFO Driver Info TextVector read only\n[I 190311 13:12:18 indiclient:580] INDIElement: DRIVER_NAME Name Text CCD Simulator\n[I 190311 13:12:18 indiclient:580] INDIElement: DRIVER_EXEC Exec Text indi_simulator_ccd\n[I 190311 13:12:18 indiclient:580] INDIElement: DRIVER_VERSION Version Text 1.0\n[I 190311 13:12:18 indiclient:580] INDIElement: DRIVER_INTERFACE Interface Text 22\n[I 190311 13:12:18 indiclient:1104] INDIVector: CCD Simulator POLLING_PERIOD Polling NumberVector read and write\n[I 190311 13:12:18 indiclient:580] INDIElement: PERIOD_MS Period (ms) Number 1000\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator CONNECTION Connection SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: CONNECT Connect Switch On\n[I 190311 13:12:18 indiclient:580] INDIElement: DISCONNECT Disconnect Switch Off\n[I 190311 13:12:18 indiclient:1104] INDIVector: Telescope Simulator DRIVER_INFO Driver Info TextVector read only\n[I 190311 13:12:18 indiclient:580] INDIElement: DRIVER_NAME Name Text Telescope Simulator\n[I 190311 13:12:18 indiclient:580] INDIElement: DRIVER_EXEC Exec Text indi_simulator_telescope\n[I 190311 13:12:18 indiclient:580] INDIElement: DRIVER_VERSION Version Text 1.0\n[I 190311 13:12:18 indiclient:580] INDIElement: DRIVER_INTERFACE Interface Text 5\n[I 190311 13:12:18 indiclient:1104] INDIVector: Telescope Simulator POLLING_PERIOD Polling NumberVector read and write\n[I 190311 13:12:18 indiclient:580] INDIElement: PERIOD_MS Period (ms) Number 250\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator DEBUG Debug SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: ENABLE Enable Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: DISABLE Disable Switch On\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator CONFIG_PROCESS Configuration SwitchVector AtMostOne\n[I 190311 13:12:18 indiclient:580] INDIElement: CONFIG_LOAD Load Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: CONFIG_SAVE Save Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: CONFIG_DEFAULT Default Switch Off\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator CONNECTION_MODE Connection Mode SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: CONNECTION_SERIAL Serial Switch On\n[I 190311 13:12:18 indiclient:580] INDIElement: CONNECTION_TCP Ethernet Switch Off\n[I 190311 13:12:18 indiclient:1104] INDIVector: Telescope Simulator DEVICE_PORT Ports TextVector read and write\n[I 190311 13:12:18 indiclient:580] INDIElement: PORT Port Text /dev/cu.usbserial\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator DEVICE_BAUD_RATE Baud Rate SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: 9600 9600 Switch On\n[I 190311 13:12:18 indiclient:580] INDIElement: 19200 19200 Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: 38400 38400 Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: 57600 57600 Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: 115200 115200 Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: 230400 230400 Switch Off\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator DEVICE_AUTO_SEARCH Auto Search SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: ENABLED Enabled Switch On\n[I 190311 13:12:18 indiclient:580] INDIElement: DISABLED Disabled Switch Off\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator DEVICE_PORT_SCAN Refresh SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: Scan Ports Scan Ports Switch Off\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator SYSTEM_PORTS System Ports SwitchVector AtMostOne\n[I 190311 13:12:18 indiclient:580] INDIElement: /dev/cu.Bluetooth-Incoming-Port /dev/cu.Bluetooth-Incoming-Port Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: /dev/cu.MALS /dev/cu.MALS Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: /dev/cu.SOC /dev/cu.SOC Switch Off\n[I 190311 13:12:18 indiclient:1104] INDIVector: Telescope Simulator ACTIVE_DEVICES Snoop devices TextVector read and write\n[I 190311 13:12:18 indiclient:580] INDIElement: ACTIVE_GPS GPS Text GPS Simulator\n[I 190311 13:12:18 indiclient:580] INDIElement: ACTIVE_DOME DOME Text Dome Simulator\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator DOME_POLICY Dome parking policy SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: NO_ACTION Ignore dome Switch On\n[I 190311 13:12:18 indiclient:580] INDIElement: LOCK_PARKING Dome locks Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: FORCE_CLOSE Dome parks Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: LOCK_AND_FORCE Both Switch Off\n[I 190311 13:12:18 indiclient:1104] INDIVector: Telescope Simulator TELESCOPE_INFO Scope Properties NumberVector read and write\n[I 190311 13:12:18 indiclient:580] INDIElement: TELESCOPE_APERTURE Aperture (mm) Number 120\n[I 190311 13:12:18 indiclient:580] INDIElement: TELESCOPE_FOCAL_LENGTH Focal Length (mm) Number 900\n[I 190311 13:12:18 indiclient:580] INDIElement: GUIDER_APERTURE Guider Aperture (mm) Number 120\n[I 190311 13:12:18 indiclient:580] INDIElement: GUIDER_FOCAL_LENGTH Guider Focal Length (mm) Number 900\n[I 190311 13:12:18 indiclient:1104] INDIVector: Telescope Simulator SCOPE_CONFIG_NAME Scope Name TextVector read and write\n[I 190311 13:12:18 indiclient:580] INDIElement: SCOPE_CONFIG_NAME Config Name Text \n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator ON_COORD_SET On Set SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: TRACK Track Switch On\n[I 190311 13:12:18 indiclient:580] INDIElement: SLEW Slew Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: SYNC Sync Switch Off\n[I 190311 13:12:18 indiclient:1104] INDIVector: Telescope Simulator EQUATORIAL_EOD_COORD Eq. Coordinates NumberVector read and write\n[I 190311 13:12:18 indiclient:580] INDIElement: RA RA (hh:mm:ss) Number 7.4845283712546706312\n[I 190311 13:12:18 indiclient:580] INDIElement: DEC DEC (dd:mm:ss) Number 90\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator TELESCOPE_ABORT_MOTION Abort Motion SwitchVector AtMostOne\n[I 190311 13:12:18 indiclient:580] INDIElement: ABORT Abort Switch Off\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator TELESCOPE_TRACK_MODE Track Mode SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: TRACK_SIDEREAL Sidereal Switch On\n[I 190311 13:12:18 indiclient:580] INDIElement: TRACK_CUSTOM Custom Switch Off\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: Telescope Simulator TELESCOPE_TRACK_STATE Tracking SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: TRACK_ON On Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: TRACK_OFF Off Switch On\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: CCD Simulator DEBUG Debug SwitchVector OneOfMany\n[I 190311 13:12:18 indiclient:580] INDIElement: ENABLE Enable Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: DISABLE Disable Switch On\n[I 190311 13:12:18 indiclient:1235] INDISwitchVector: CCD Simulator CONFIG_PROCESS Configuration SwitchVector AtMostOne\n[I 190311 13:12:18 indiclient:580] INDIElement: CONFIG_LOAD Load Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: CONFIG_SAVE Save Switch Off\n[I 190311 13:12:18 indiclient:580] INDIElement: CONFIG_DEFAULT Default Switch Off\n[I 190311 13:12:18 indiclient:1104] INDIVector: CCD Simulator ACTIVE_DEVICES Snoop devices TextVector read and write\n[I 190311 13:12:18 indiclient:580] INDIElement: ACTIVE_TELESCOPE Telescope Text Telescope Simulator\n[I 190311 13:12:18 indiclient:580] INDIElement: ACTIVE_FOCUSER Focuser Text Focuser Simulator\n[I 190311 13:12:18 indiclient:580] INDIElement: ACTIVE_FILTER Filter Text CCD Simulator\n" ], [ "c.cooler", "_____no_output_____" ], [ "sys.getsizeof(s.camera)", "_____no_output_____" ], [ "# filter 1 -> R\n# filter 2 -> V\n# filter 3 -> B\n# filter 4 -> clear\nc.filter", "_____no_output_____" ], [ "c.currentElement", "_____no_output_____" ], [ "f = c.expose(exptime=60, exptype=\"Light\")", "_____no_output_____" ], [ "norm = visualization.ImageNormalize(\n f[0].data,\n interval=visualization.ZScaleInterval(),\n stretch=visualization.AsinhStretch()\n)\nplt.imshow(f[0].data, norm=norm)\nplt.show()", "_____no_output_____" ], [ "f.writeto(\"globular.fits\", clobber=True)", "_____no_output_____" ], [ "f[0].header", "_____no_output_____" ], [ "int(c.get_float(\"SBIG CCD\", \"FILTER_SLOT\", \"FILTER_SLOT_VALUE\"))", "_____no_output_____" ], [ "c.temperature", "_____no_output_____" ] ], [ [ "# F/9 WFS Camera dev", "_____no_output_____" ] ], [ [ "f9 = F9WFSCam()", "_____no_output_____" ], [ "f9.process_events()", "_____no_output_____" ], [ "v = f9.get_vector(\"SBIG CCD\", \"CCD_BINNING\")\ne = v.elements[0]", "_____no_output_____" ], [ "for e in v.elements:\n print(\"%s %s\" % (e.getName(), e.get_int()))", "_____no_output_____" ], [ "f9.connected", "_____no_output_____" ], [ "f9.process_events()", "_____no_output_____" ], [ "f9.wfs_config()", "_____no_output_____" ], [ "f9.default_config()", "_____no_output_____" ], [ "f9.binning", "_____no_output_____" ], [ "f9.process_events()\nf = f9.expose(exptime=1.0, exptype=\"Light\")", "_____no_output_____" ], [ "norm = visualization.ImageNormalize(\n f[0].data,\n interval=visualization.ZScaleInterval(),\n stretch=visualization.AsinhStretch()\n)\nplt.imshow(f[0].data, norm=norm)\nplt.show()", "_____no_output_____" ], [ "f.writeto(\"f9_sbig_ref.fits\")", "_____no_output_____" ], [ "f[0].data.max()", "_____no_output_____" ], [ "f9.temperature = 20", "_____no_output_____" ], [ "f9.get_float(\"SBIG CCD\", \"CCD_TEMPERATURE\", \"CCD_TEMPERATURE_VALUE\")", "_____no_output_____" ], [ "v = f9.get_vector(\"SBIG CCD\", \"CCD_TEMPERATURE\")\nv.get_element(\"CCD_TEMPERATURE_VALUE\").get_float()", "_____no_output_____" ], [ "f9.get_float(\"SBIG CCD\", \"CCD_COOLER_POWER\", \"CCD_COOLER_VALUE\")", "_____no_output_____" ], [ "f9.temperature", "_____no_output_____" ], [ "f9.cooling_power", "_____no_output_____" ], [ "f9.cooler", "_____no_output_____" ], [ "f[0].header", "_____no_output_____" ], [ "f9.observer = \"F/9 WFS\"", "_____no_output_____" ], [ "f9.object = \"reference\"", "_____no_output_____" ], [ "f[0].header", "_____no_output_____" ], [ "f9.tell()", "_____no_output_____" ], [ "f9.process_events()", "_____no_output_____" ] ] ]

[ "code", "markdown", "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Temporal-Difference Methods\n\nIn this notebook, you will write your own implementations of many Temporal-Difference (TD) methods.\n\nWhile we have provided some starter code, you are welcome to erase these hints and write your code from scratch.\n\n---\n\n### Part 0: Explore CliffWalkingEnv\n\nWe begin by importing the necessary packages.", "_____no_output_____" ] ], [ [ "import sys\nimport gym\nimport numpy as np\nimport random\nimport math\nfrom collections import defaultdict, deque\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nimport check_test\nfrom plot_utils import plot_values", "_____no_output_____" ] ], [ [ "Use the code cell below to create an instance of the [CliffWalking](https://github.com/openai/gym/blob/master/gym/envs/toy_text/cliffwalking.py) environment.", "_____no_output_____" ] ], [ [ "env = gym.make('CliffWalking-v0')", "_____no_output_____" ] ], [ [ "The agent moves through a $4\\times 12$ gridworld, with states numbered as follows:\n```\n[[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],\n [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23],\n [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35],\n [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47]]\n```\nAt the start of any episode, state `36` is the initial state. State `47` is the only terminal state, and the cliff corresponds to states `37` through `46`.\n\nThe agent has 4 potential actions:\n```\nUP = 0\nRIGHT = 1\nDOWN = 2\nLEFT = 3\n```\n\nThus, $\\mathcal{S}^+=\\{0, 1, \\ldots, 47\\}$, and $\\mathcal{A} =\\{0, 1, 2, 3\\}$. Verify this by running the code cell below.", "_____no_output_____" ] ], [ [ "print(env.action_space)\nprint(env.observation_space)", "Discrete(4)\nDiscrete(48)\n" ] ], [ [ "In this mini-project, we will build towards finding the optimal policy for the CliffWalking environment. The optimal state-value function is visualized below. Please take the time now to make sure that you understand _why_ this is the optimal state-value function.\n\n_**Note**: You can safely ignore the values of the cliff \"states\" as these are not true states from which the agent can make decisions. For the cliff \"states\", the state-value function is not well-defined._", "_____no_output_____" ] ], [ [ "# define the optimal state-value function\nV_opt = np.zeros((4,12))\nV_opt[0][0:13] = -np.arange(3, 15)[::-1]\nV_opt[1][0:13] = -np.arange(3, 15)[::-1] + 1\nV_opt[2][0:13] = -np.arange(3, 15)[::-1] + 2\nV_opt[3][0] = -13\n\nplot_values(V_opt)", "_____no_output_____" ] ], [ [ "### Part 1: TD Control: Sarsa\n\nIn this section, you will write your own implementation of the Sarsa control algorithm.\n\nYour algorithm has four arguments:\n- `env`: This is an instance of an OpenAI Gym environment.\n- `num_episodes`: This is the number of episodes that are generated through agent-environment interaction.\n- `alpha`: This is the step-size parameter for the update step.\n- `gamma`: This is the discount rate. It must be a value between 0 and 1, inclusive (default value: `1`).\n\nThe algorithm returns as output:\n- `Q`: This is a dictionary (of one-dimensional arrays) where `Q[s][a]` is the estimated action value corresponding to state `s` and action `a`.\n\nPlease complete the function in the code cell below.\n\n(_Feel free to define additional functions to help you to organize your code._)", "_____no_output_____" ] ], [ [ "def update_Q_sarsa(alpha, gamma, Q, state, action, reward, next_state=None, next_action=None):\n \"\"\"Returns updated Q-value for the most recent experience.\"\"\"\n current = Q[state][action] # estimate in Q-table (for current state, action pair)\n # get value of state, action pair at next time step\n Qsa_next = Q[next_state][next_action] if next_state is not None else 0 \n target = reward + (gamma * Qsa_next) # construct TD target\n new_value = current + (alpha * (target - current)) # get updated value\n return new_value\n\ndef epsilon_greedy(Q, state, nA, eps):\n \"\"\"Selects epsilon-greedy action for supplied state.\n \n Params\n ======\n Q (dictionary): action-value function\n state (int): current state\n nA (int): number actions in the environment\n eps (float): epsilon\n \"\"\"\n if random.random() > eps: # select greedy action with probability epsilon\n return np.argmax(Q[state])\n else: # otherwise, select an action randomly\n return random.choice(np.arange(env.action_space.n))", "_____no_output_____" ], [ "def sarsa(env, num_episodes, alpha, gamma=1.0, plot_every=100):\n nA = env.action_space.n # number of actions\n Q = defaultdict(lambda: np.zeros(nA)) # initialize empty dictionary of arrays\n \n # monitor performance\n tmp_scores = deque(maxlen=plot_every) # deque for keeping track of scores\n avg_scores = deque(maxlen=num_episodes) # average scores over every plot_every episodes\n \n for i_episode in range(1, num_episodes+1):\n # monitor progress\n if i_episode % 100 == 0:\n print(\"\\rEpisode {}/{}\".format(i_episode, num_episodes), end=\"\")\n sys.stdout.flush() \n score = 0 # initialize score\n state = env.reset() # start episode\n \n eps = 1.0 / i_episode # set value of epsilon\n action = epsilon_greedy(Q, state, nA, eps) # epsilon-greedy action selection\n \n while True:\n next_state, reward, done, info = env.step(action) # take action A, observe R, S'\n score += reward # add reward to agent's score\n if not done:\n next_action = epsilon_greedy(Q, next_state, nA, eps) # epsilon-greedy action\n Q[state][action] = update_Q_sarsa(alpha, gamma, Q, \\\n state, action, reward, next_state, next_action)\n \n state = next_state # S <- S'\n action = next_action # A <- A'\n if done:\n Q[state][action] = update_Q_sarsa(alpha, gamma, Q, \\\n state, action, reward)\n tmp_scores.append(score) # append score\n break\n if (i_episode % plot_every == 0):\n avg_scores.append(np.mean(tmp_scores))\n\n # plot performance\n plt.plot(np.linspace(0,num_episodes,len(avg_scores),endpoint=False), np.asarray(avg_scores))\n plt.xlabel('Episode Number')\n plt.ylabel('Average Reward (Over Next %d Episodes)' % plot_every)\n plt.show()\n # print best 100-episode performance\n print(('Best Average Reward over %d Episodes: ' % plot_every), np.max(avg_scores)) \n return Q", "_____no_output_____" ] ], [ [ "Use the next code cell to visualize the **_estimated_** optimal policy and the corresponding state-value function. \n\nIf the code cell returns **PASSED**, then you have implemented the function correctly! Feel free to change the `num_episodes` and `alpha` parameters that are supplied to the function. However, if you'd like to ensure the accuracy of the unit test, please do not change the value of `gamma` from the default.", "_____no_output_____" ] ], [ [ "# obtain the estimated optimal policy and corresponding action-value function\nQ_sarsa = sarsa(env, 50000, .01)\n\n# print the estimated optimal policy\npolicy_sarsa = np.array([np.argmax(Q_sarsa[key]) if key in Q_sarsa else -1 for key in np.arange(48)]).reshape(4,12)\ncheck_test.run_check('td_control_check', policy_sarsa)\nprint(\"\\nEstimated Optimal Policy (UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3, N/A = -1):\")\nprint(policy_sarsa)\n\n# plot the estimated optimal state-value function\nV_sarsa = ([np.max(Q_sarsa[key]) if key in Q_sarsa else 0 for key in np.arange(48)])\nplot_values(V_sarsa)", "Episode 50000/50000" ] ], [ [ "### Part 2: TD Control: Q-learning\n\nIn this section, you will write your own implementation of the Q-learning control algorithm.\n\nYour algorithm has four arguments:\n- `env`: This is an instance of an OpenAI Gym environment.\n- `num_episodes`: This is the number of episodes that are generated through agent-environment interaction.\n- `alpha`: This is the step-size parameter for the update step.\n- `gamma`: This is the discount rate. It must be a value between 0 and 1, inclusive (default value: `1`).\n\nThe algorithm returns as output:\n- `Q`: This is a dictionary (of one-dimensional arrays) where `Q[s][a]` is the estimated action value corresponding to state `s` and action `a`.\n\nPlease complete the function in the code cell below.\n\n(_Feel free to define additional functions to help you to organize your code._)", "_____no_output_____" ] ], [ [ "def update_Q_sarsamax(alpha, gamma, Q, state, action, reward, next_state=None):\n \"\"\"Returns updated Q-value for the most recent experience.\"\"\"\n current = Q[state][action] # estimate in Q-table (for current state, action pair)\n Qsa_next = np.max(Q[next_state]) if next_state is not None else 0 # value of next state \n target = reward + (gamma * Qsa_next) # construct TD target\n new_value = current + (alpha * (target - current)) # get updated value \n return new_value", "_____no_output_____" ], [ "def q_learning(env, num_episodes, alpha, gamma=1.0, plot_every=100):\n \"\"\"Q-Learning - TD Control\n \n Params\n ======\n num_episodes (int): number of episodes to run the algorithm\n alpha (float): learning rate\n gamma (float): discount factor\n plot_every (int): number of episodes to use when calculating average score\n \"\"\"\n nA = env.action_space.n # number of actions\n Q = defaultdict(lambda: np.zeros(nA)) # initialize empty dictionary of arrays\n \n # monitor performance\n tmp_scores = deque(maxlen=plot_every) # deque for keeping track of scores\n avg_scores = deque(maxlen=num_episodes) # average scores over every plot_every episodes\n \n for i_episode in range(1, num_episodes+1):\n # monitor progress\n if i_episode % 100 == 0:\n print(\"\\rEpisode {}/{}\".format(i_episode, num_episodes), end=\"\")\n sys.stdout.flush()\n score = 0 # initialize score\n state = env.reset() # start episode\n eps = 1.0 / i_episode # set value of epsilon\n \n while True:\n action = epsilon_greedy(Q, state, nA, eps) # epsilon-greedy action selection\n next_state, reward, done, info = env.step(action) # take action A, observe R, S'\n score += reward # add reward to agent's score\n Q[state][action] = update_Q_sarsamax(alpha, gamma, Q, \\\n state, action, reward, next_state) \n state = next_state # S <- S'\n if done:\n tmp_scores.append(score) # append score\n break\n if (i_episode % plot_every == 0):\n avg_scores.append(np.mean(tmp_scores))\n \n # plot performance\n plt.plot(np.linspace(0,num_episodes,len(avg_scores),endpoint=False), np.asarray(avg_scores))\n plt.xlabel('Episode Number')\n plt.ylabel('Average Reward (Over Next %d Episodes)' % plot_every)\n plt.show()\n # print best 100-episode performance\n print(('Best Average Reward over %d Episodes: ' % plot_every), np.max(avg_scores))\n return Q", "_____no_output_____" ] ], [ [ "Use the next code cell to visualize the **_estimated_** optimal policy and the corresponding state-value function. \n\nIf the code cell returns **PASSED**, then you have implemented the function correctly! Feel free to change the `num_episodes` and `alpha` parameters that are supplied to the function. However, if you'd like to ensure the accuracy of the unit test, please do not change the value of `gamma` from the default.", "_____no_output_____" ] ], [ [ "# obtain the estimated optimal policy and corresponding action-value function\nQ_sarsamax = q_learning(env, 5000, .01)\n\n# print the estimated optimal policy\npolicy_sarsamax = np.array([np.argmax(Q_sarsamax[key]) if key in Q_sarsamax else -1 for key in np.arange(48)]).reshape((4,12))\ncheck_test.run_check('td_control_check', policy_sarsamax)\nprint(\"\\nEstimated Optimal Policy (UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3, N/A = -1):\")\nprint(policy_sarsamax)\n\n# plot the estimated optimal state-value function\nplot_values([np.max(Q_sarsamax[key]) if key in Q_sarsamax else 0 for key in np.arange(48)])", "Episode 5000/5000" ] ], [ [ "### Part 3: TD Control: Expected Sarsa\n\nIn this section, you will write your own implementation of the Expected Sarsa control algorithm.\n\nYour algorithm has four arguments:\n- `env`: This is an instance of an OpenAI Gym environment.\n- `num_episodes`: This is the number of episodes that are generated through agent-environment interaction.\n- `alpha`: This is the step-size parameter for the update step.\n- `gamma`: This is the discount rate. It must be a value between 0 and 1, inclusive (default value: `1`).\n\nThe algorithm returns as output:\n- `Q`: This is a dictionary (of one-dimensional arrays) where `Q[s][a]` is the estimated action value corresponding to state `s` and action `a`.\n\nPlease complete the function in the code cell below.\n\n(_Feel free to define additional functions to help you to organize your code._)", "_____no_output_____" ] ], [ [ "def update_Q_expsarsa(alpha, gamma, nA, eps, Q, state, action, reward, next_state=None):\n \"\"\"Returns updated Q-value for the most recent experience.\"\"\"\n current = Q[state][action] # estimate in Q-table (for current state, action pair)\n policy_s = np.ones(nA) * eps / nA # current policy (for next state S')\n policy_s[np.argmax(Q[next_state])] = 1 - eps + (eps / nA) # greedy action\n Qsa_next = np.dot(Q[next_state], policy_s) # get value of state at next time step\n target = reward + (gamma * Qsa_next) # construct target\n new_value = current + (alpha * (target - current)) # get updated value \n return new_value", "_____no_output_____" ], [ "def expected_sarsa(env, num_episodes, alpha, gamma=1.0, plot_every=100):\n \"\"\"Expected SARSA - TD Control\n \n Params\n ======\n num_episodes (int): number of episodes to run the algorithm\n alpha (float): step-size parameters for the update step\n gamma (float): discount factor\n plot_every (int): number of episodes to use when calculating average score\n \"\"\"\n nA = env.action_space.n # number of actions\n Q = defaultdict(lambda: np.zeros(nA)) # initialize empty dictionary of arrays\n \n # monitor performance\n tmp_scores = deque(maxlen=plot_every) # deque for keeping track of scores\n avg_scores = deque(maxlen=num_episodes) # average scores over every plot_every episodes\n \n for i_episode in range(1, num_episodes+1):\n # monitor progress\n if i_episode % 100 == 0:\n print(\"\\rEpisode {}/{}\".format(i_episode, num_episodes), end=\"\")\n sys.stdout.flush()\n \n score = 0 # initialize score\n state = env.reset() # start episode\n eps = 0.005 # set value of epsilon\n \n while True:\n action = epsilon_greedy(Q, state, nA, eps) # epsilon-greedy action selection\n next_state, reward, done, info = env.step(action) # take action A, observe R, S'\n score += reward # add reward to agent's score\n # update Q\n Q[state][action] = update_Q_expsarsa(alpha, gamma, nA, eps, Q, \\\n state, action, reward, next_state) \n state = next_state # S <- S'\n if done:\n tmp_scores.append(score) # append score\n break\n if (i_episode % plot_every == 0):\n avg_scores.append(np.mean(tmp_scores))\n \n # plot performance\n plt.plot(np.linspace(0,num_episodes,len(avg_scores),endpoint=False), np.asarray(avg_scores))\n plt.xlabel('Episode Number')\n plt.ylabel('Average Reward (Over Next %d Episodes)' % plot_every)\n plt.show()\n # print best 100-episode performance\n print(('Best Average Reward over %d Episodes: ' % plot_every), np.max(avg_scores))\n return Q", "_____no_output_____" ] ], [ [ "Use the next code cell to visualize the **_estimated_** optimal policy and the corresponding state-value function. \n\nIf the code cell returns **PASSED**, then you have implemented the function correctly! Feel free to change the `num_episodes` and `alpha` parameters that are supplied to the function. However, if you'd like to ensure the accuracy of the unit test, please do not change the value of `gamma` from the default.", "_____no_output_____" ] ], [ [ "# obtain the estimated optimal policy and corresponding action-value function\nQ_expsarsa = expected_sarsa(env, 50000, 1)\n\n# print the estimated optimal policy\npolicy_expsarsa = np.array([np.argmax(Q_expsarsa[key]) if key in Q_expsarsa else -1 for key in np.arange(48)]).reshape(4,12)\ncheck_test.run_check('td_control_check', policy_expsarsa)\nprint(\"\\nEstimated Optimal Policy (UP = 0, RIGHT = 1, DOWN = 2, LEFT = 3, N/A = -1):\")\nprint(policy_expsarsa)\n\n# plot the estimated optimal state-value function\nplot_values([np.max(Q_expsarsa[key]) if key in Q_expsarsa else 0 for key in np.arange(48)])", "Episode 50000/50000" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ] ]

[ "CC-BY-4.0" ]

[ "CC-BY-4.0" ]

[ "CC-BY-4.0" ]

[ [ [ "# Lists", "_____no_output_____" ], [ "### A list stores many values in a single structure.", "_____no_output_____" ], [ "### Use an item’s index to fetch it from a list.", "_____no_output_____" ], [ "### Lists’ values can be replaced by assigning to them.", "_____no_output_____" ], [ "### Appending items to a list lengthens it.", "_____no_output_____" ], [ "### Use `del` to remove items from a list entirely.", "_____no_output_____" ], [ "### The empty list contains no values.", "_____no_output_____" ], [ "### Lists may contain values of different types.", "_____no_output_____" ], [ "### Character strings can be indexed like lists.", "_____no_output_____" ], [ "but character strings are _immutable_.", "_____no_output_____" ], [ "### Indexing beyond the end of the collection is an error.", "_____no_output_____" ], [ "## Exercises", "_____no_output_____" ] ], [ [ "%load ../exercises/lists-blanks.py", "_____no_output_____" ], [ "%load ../exercises/lists-string-conversion.py", "_____no_output_____" ] ], [ [ "## Key Points", "_____no_output_____" ], [ "- A list stores many values in a single structure.\n- Use an item’s index to fetch it from a list.\n- Lists’ values can be replaced by assigning to them.\n- Appending items to a list lengthens it.\n- Use del to remove items from a list entirely.\n- The empty list contains no values.\n- Lists may contain values of different types.\n- Character strings can be indexed like lists.\n- Character strings are immutable.\n- Indexing beyond the end of the collection is an error.", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ] ]

[ "WTFPL" ]

[ "WTFPL" ]

[ "WTFPL" ]

[ [ [ "empty" ] ] ]

[ "empty" ]

[ [ "empty" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Measure without a Loop\n\nIf you have a parameter that returns a whole array at once, often you want to measure it directly into a DataSet.\n\nThis shows how that works in QCoDeS", "_____no_output_____" ] ], [ [ "%matplotlib nbagg\nimport qcodes as qc\nimport numpy as np\n# import dummy driver for the tutorial\nfrom qcodes.tests.instrument_mocks import DummyInstrument, DummyChannelInstrument\nfrom qcodes.measure import Measure\nfrom qcodes.actions import Task\n\ndac1 = DummyInstrument(name=\"dac\")\ndac2 = DummyChannelInstrument(name=\"dac2\")\n\n\n# the default dummy instrument returns always a constant value, in the following line we make it random \n# just for the looks 💅\ndac2.A.dummy_array_parameter.get = lambda: np.random.randint(0, 100, size=5)\n\n# The station is a container for all instruments that makes it easy \n# to log meta-data\nstation = qc.Station(dac1, dac2)", "2020-03-24 18:45:32,769 ¦ qcodes.instrument.base ¦ WARNING ¦ base ¦ snapshot_base ¦ 214 ¦ [dac2_ChanA(DummyChannel)] Snapshot: Could not update parameter: dummy_sp_axis\n2020-03-24 18:45:32,798 ¦ qcodes.instrument.base ¦ WARNING ¦ base ¦ snapshot_base ¦ 214 ¦ [dac2_ChanB(DummyChannel)] Snapshot: Could not update parameter: dummy_sp_axis\n2020-03-24 18:45:32,804 ¦ qcodes.instrument.base ¦ WARNING ¦ base ¦ snapshot_base ¦ 214 ¦ [dac2_ChanC(DummyChannel)] Snapshot: Could not update parameter: dummy_sp_axis\n2020-03-24 18:45:32,807 ¦ qcodes.instrument.base ¦ WARNING ¦ base ¦ snapshot_base ¦ 214 ¦ [dac2_ChanD(DummyChannel)] Snapshot: Could not update parameter: dummy_sp_axis\n2020-03-24 18:45:32,819 ¦ qcodes.instrument.base ¦ WARNING ¦ base ¦ snapshot_base ¦ 214 ¦ [dac2_ChanE(DummyChannel)] Snapshot: Could not update parameter: dummy_sp_axis\n2020-03-24 18:45:32,838 ¦ qcodes.instrument.base ¦ WARNING ¦ base ¦ snapshot_base ¦ 214 ¦ [dac2_ChanF(DummyChannel)] Snapshot: Could not update parameter: dummy_sp_axis\n" ] ], [ [ "## Instantiates all the instruments needed for the demo\n\nFor this tutorial we're going to use the regular parameters (c0, c1, c2, vsd) and ArrayGetter, which is just a way to construct a parameter that returns a whole array at once out of simple parameters, as well as AverageAndRaw, which returns a scalar *and* an array together.", "_____no_output_____" ], [ "### Only array output\nThe arguments to Measure are all the same actions you use in a Loop.\nIf they return only arrays, you will see exactly those arrays (with their setpoints) in the output DataSet", "_____no_output_____" ] ], [ [ "data = Measure(\n Task(dac1.dac1.set, 0),\n dac2.A.dummy_array_parameter,\n Task(dac1.dac1.set, 2),\n dac2.A.dummy_array_parameter,\n).run()", "DataSet:\n location = 'data/2020-03-24/#013_{name}_18-45-41'\n <Type> | <array_id> | <array.name> | <array.shape>\n Measured | dac2_ChanA_dummy_array_parameter_1 | dummy_array_parameter | (5,)\n Measured | dac2_ChanA_dummy_array_parameter_3 | dummy_array_parameter | (5,)\nacquired at 2020-03-24 18:45:41\n" ] ] ]

[ "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import re \nimport pandas as pd\nimport os \nimport html", "_____no_output_____" ], [ "os.chdir('/Users/lindsayduca/Desktop/Downloads')\n#file=\"US20220000001A1-20220106.XML\" \n#file=\"USD0864516-20191029.XML\" \n\nfile = open(file=\"ipa220106.txt\", mode='r') #opening the file in read mode\nfile_content_raw = file.read()\nfile.close()\ntext1=re.compile(\"<\\?xml version=\\\"1\\.0\\\" encoding\\=\\\"UTF\\-8\\\"\\?>\")\nfile_content = text1.split(file_content_raw)\nwhile '' in file_content:\n file_content.remove('')\nprint(\"No of patents :\", len(file_content)) ", "No of patents : 7882\n" ], [ "# Writing regular expressions for the desired columns\n\n#grant_id = re.compile('file\\=\\\"([U][S]\\w\\w\\d{6})\\-\\d{8}\\.XML\\\"') \ngrant_id = re.compile('file\\=\\\"([U][S]\\w{13})\\-\\w{8}\\.[X][M][L]\\\"') \n\n#patent_title = re.compile(\"<invention-title id=\\\"\\w{5,6}\\\">(.*?)</invention-title>\") \nkind = re.compile(\"<kind>([A-Z]\\d)</kind>\")\n#number_of_claim = re.compile(\"\\<number\\-of\\-claims\\>(\\d{1,4})\\<\\/number\\-of\\-claims\\>\")\nfirst_name=re.compile(\"<first-name>(.*?)</first-name>\")\nlast_name=re.compile(\"<last-name>(.*?)</last-name>\")\ncitation_by_examiner = re.compile(\"\\<category\\>cited by examiner<\\/category\\>\")\ncitation_by_applicant = re.compile(\"\\<category>cited by applicant\\<\\/category\\>\")\nclaim_text=re.compile(\"<claim-text>[\\s\\S<]*</claim-text>\")\nabstract=re.compile(\"\\<abstract id\\=\\\"abstract\\\"\\>\\n\\<p id\\=\\\"p\\-0001\\\" num\\=\\\"0000\\\"\\>(.*?)\\<\\/p\\>\\n\\<\\/abstract\\>\")\n\n# some extra care with claim-text\ncleaner = re.compile('<.*?>') \ncleaner2 = re.compile('\\n')\ncleaner3 = re.compile('\\,\\,\\,')\ncleaner4 = re.compile(\"[\\.][\\,][\\,]\")\ncleaner5 = re.compile(\"[\\,][\\,]\")\ncleaner6 = re.compile(\"[\\;][\\,]\")", "_____no_output_____" ], [ "for line in file_content:\n \n gid=grant_id.findall(line) #to find grant_id\n \n# checking length of gid is not equal to 0 then do append to all the lists\n if len(gid)!=0: \n gid_list.append(gid[0])\n \ndata_frame = pd.DataFrame(\n {'grant_id': gid_list})\ndata_frame", "_____no_output_____" ], [ "gid_list, title_list, kind_list, no_of_claim_list, name_list, applicant_list, examiners_list, claim_list, abstract_list, = ([] for i in range(9))\n\nfor line in file_content:\n \n gid=grant_id.findall(line) #to find grant_id\n title=patent_title.findall(line) #to find patent_title\n kinds=kind.findall(line) #to find kind\n # sclaim=number_of_claim.findall(line) #to find no_of_claims\n #to find inventors\n inventors=re.findall(\"<inventor.*?>[\\s\\S]*</inventor>\",line)\n for person in inventors:\n first=first_name.findall(person)\n last=last_name.findall(person)\n name = [firstName +\" \"+ lastName for firstName, lastName in zip(first,last)]\n if len(name)==0:\n names=\"NA\"\n else:\n names=name\n \n # here we count citation_by_applicant\n if len(citation_by_applicant.findall(line))==0:\n citation_by_applicants=0\n else:\n citation_by_applicants=len(citation_by_applicant.findall(line)) \n \n # count for citation_by_examiner\n if len(citation_by_examiner.findall(line))==0:\n citation_by_examiners=0\n else: \n citation_by_examiners=len(citation_by_examiner.findall(line)) \n \n # For claim_text\n if (len(re.findall(\"<claim-text>[\\s\\S<]*</claim-text>\",line))==0):\n claim_text=[\"NA\"]\n else:\n claim_text=re.findall(\"<claim-text>[\\s\\S<]*</claim-text>\",line) \n \n # For abstract\n abst=abstract.findall(line)\n if len(abst)==0:\n abstracts=[\"NA\"]\n else: \n abstracts=abst \n \n # checking length of gid is not equal to 0 then do append to all the lists\n if len(gid)!=0: \n gid_list.append(gid[0])\n # title_list.append(title[0])\n kind_list.append(kinds[0])\n # no_of_claim_list.append(sclaim[0])\n name_list.append(names)\n applicant_list.append(citation_by_applicants)\n examiners_list.append(citation_by_examiners)\n claim_list.append(claim_text[0])\n abstract_list.append(abstracts[0])\n\"\"\" \n# cleaning claim text \nelement=0\nfor items in claim_list:\n claim_list[element]=re.sub(cleaner,'',claim_list[element])\n claim_list[element]=re.sub(cleaner2,',',claim_list[element])\n claim_list[element]=re.sub(cleaner3,',',claim_list[element])\n claim_list[element]=re.sub(cleaner4,'.,',claim_list[element])\n claim_list[element]=re.sub(cleaner5,',',claim_list[element])\n claim_list[element]=re.sub(cleaner6,'; ',claim_list[element])\n element=element+1\n\"\"\"\n# For kind \nKind1 = [w.replace('P2', 'Plant Patent Grant(with a published application) issued on or after January 2, 2001') for w in kind_list]\nKind2 = [w.replace('B2', 'Utility Patent Grant (with a published application) issued on or after January 2, 2001.') for w in Kind1]\nKind3 = [w.replace('S1', 'Design Patent') for w in Kind2]\nKind4 = [w.replace('B1', 'Utility Patent Grant (no published application) issued on or after January 2, 2001.') for w in Kind3]", "_____no_output_____" ], [ "# Creating data frame\ndata_frame = pd.DataFrame(\n {'grant_id': gid_list,\n #'patent_title': title_list,\n 'kind': Kind4,\n #'number_of_claims':no_of_claim_list,\n 'inventors':name_list,\n 'citations_applicant_count':applicant_list,\n 'citations_examiner_count':examiners_list,\n 'claims_text':claim_list,\n 'abstract':abstract_list\n })", "_____no_output_____" ], [ "data_frame.isnull().sum()", "_____no_output_____" ], [ "data_frame", "_____no_output_____" ], [ "data_frame.to_csv('ParsedPatentGrant.csv')", "_____no_output_____" ], [ "import requests\nfrom bs4 import BeautifulSoup\nimport json\n\nr = requests.get(\"https://developer.uspto.gov/ibd-api/v1/patent/application?patentNumber=9876543&start=0&rows=100\")\nsoup = BeautifulSoup(r.text, \"html.parser\")\ntext = soup.get_text()\n\nr_dict = json.loads(str(text))\nprint(r_dict['response']['docs'][0]['inventor'][0])", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "Apache-2.0", "MIT" ]

[ "Apache-2.0", "MIT" ]

[ "Apache-2.0", "MIT" ]

[ [ [ "# Loads pre-trained model and get prediction on validation samples", "_____no_output_____" ], [ "### 1. Info\nPlease provide path to the relevant config file ", "_____no_output_____" ] ], [ [ "config_file_path = \"../configs/pretrained/config_model1.json\"", "_____no_output_____" ] ], [ [ "### 2. Importing required modules", "_____no_output_____" ] ], [ [ "import os\nimport cv2\nimport sys\nimport importlib\nimport torch\nimport torchvision\nimport numpy as np\n\nsys.path.insert(0, \"../\")\n\n# imports for displaying a video an IPython cell\nimport io\nimport base64\nfrom IPython.display import HTML", "_____no_output_____" ], [ "from data_parser import WebmDataset\nfrom data_loader_av import VideoFolder\n\nfrom models.multi_column import MultiColumn\nfrom transforms_video import *\n\nfrom utils import load_json_config, remove_module_from_checkpoint_state_dict\nfrom pprint import pprint", "_____no_output_____" ] ], [ [ "### 3. Loading configuration file, model definition and its path", "_____no_output_____" ] ], [ [ "# Load config file\nconfig = load_json_config(config_file_path)", "_____no_output_____" ], [ "# set column model\ncolumn_cnn_def = importlib.import_module(\"{}\".format(config['conv_model']))\nmodel_name = config[\"model_name\"]\n\nprint(\"=> Name of the model -- {}\".format(model_name))\n\n# checkpoint path to a trained model\ncheckpoint_path = os.path.join(\"../\", config[\"output_dir\"], config[\"model_name\"], \"model_best.pth.tar\")\nprint(\"=> Checkpoint path --> {}\".format(checkpoint_path))", "=> Name of the model -- model3D_1\n=> Checkpoint path --> ../trained_models/pretrained/model3D_1/model_best.pth.tar\n" ] ], [ [ "### 3. Load model", "_____no_output_____" ], [ "_Note: without cuda() for ease_", "_____no_output_____" ] ], [ [ "model = MultiColumn(config['num_classes'], column_cnn_def.Model, int(config[\"column_units\"]))\nmodel.eval();", "_____no_output_____" ], [ "print(\"=> loading checkpoint\")\ncheckpoint = torch.load(checkpoint_path)\ncheckpoint['state_dict'] = remove_module_from_checkpoint_state_dict(\n checkpoint['state_dict'])\nmodel.load_state_dict(checkpoint['state_dict'])\nprint(\"=> loaded checkpoint '{}' (epoch {})\"\n .format(checkpoint_path, checkpoint['epoch']))", "=> loading checkpoint\n=> loaded checkpoint '../trained_models/pretrained/model3D_1/model_best.pth.tar' (epoch 55)\n" ] ], [ [ "### 4. Load data", "_____no_output_____" ] ], [ [ "# Center crop videos during evaluation\ntransform_eval_pre = ComposeMix([\n [Scale(config['input_spatial_size']), \"img\"],\n [torchvision.transforms.ToPILImage(), \"img\"],\n [torchvision.transforms.CenterCrop(config['input_spatial_size']), \"img\"]\n ])\n\ntransform_post = ComposeMix([\n [torchvision.transforms.ToTensor(), \"img\"],\n [torchvision.transforms.Normalize(\n mean=[0.485, 0.456, 0.406], # default values for imagenet\n std=[0.229, 0.224, 0.225]), \"img\"]\n ])\n\nval_data = VideoFolder(root=config['data_folder'],\n json_file_input=config['json_data_val'],\n json_file_labels=config['json_file_labels'],\n clip_size=config['clip_size'],\n nclips=config['nclips_val'],\n step_size=config['step_size_val'],\n is_val=True,\n transform_pre=transform_eval_pre,\n transform_post=transform_post,\n get_item_id=True,\n )\ndict_two_way = val_data.classes_dict", "_____no_output_____" ] ], [ [ "### 5. Get predictions", "_____no_output_____" ], [ "#### 5.1. Select random sample (or specify the index)", "_____no_output_____" ] ], [ [ "selected_indx = np.random.randint(len(val_data))\n# selected_indx = 136", "_____no_output_____" ] ], [ [ "#### 5.2 Get data in required format", "_____no_output_____" ] ], [ [ "input_data, target, item_id = val_data[selected_indx]\ninput_data = input_data.unsqueeze(0)\nprint(\"Id of the video sample = {}\".format(item_id))\nprint(\"True label --> {} ({})\".format(target, dict_two_way[target]))", "Id of the video sample = 166766\nTrue label --> 57 (Poking something so that it falls over)\n" ], [ "if config['nclips_val'] > 1:\n input_var = list(input_data.split(config['clip_size'], 2))\n for idx, inp in enumerate(input_var):\n input_var[idx] = torch.autograd.Variable(inp)\nelse:\n input_var = [torch.autograd.Variable(input_data)]", "_____no_output_____" ] ], [ [ "#### 5.3 Compute output from the model", "_____no_output_____" ] ], [ [ "output = model(input_var).squeeze(0)\noutput = torch.nn.functional.softmax(output, dim=0)", "_____no_output_____" ], [ "# compute top5 predictions\npred_prob, pred_top5 = output.data.topk(5)\npred_prob = pred_prob.numpy()\npred_top5 = pred_top5.numpy()", "_____no_output_____" ] ], [ [ "#### 5.4 Visualize predictions", "_____no_output_____" ] ], [ [ "print(\"Id of the video sample = {}\".format(item_id))\nprint(\"True label --> {} ({})\".format(target, dict_two_way[target]))\nprint(\"\\nTop-5 Predictions:\")\nfor i, pred in enumerate(pred_top5):\n print(\"Top {} :== {}. Prob := {:.2f}%\".format(i + 1, dict_two_way[pred], pred_prob[i] * 100))", "Id of the video sample = 166766\nTrue label --> 57 (Poking something so that it falls over)\n\nTop-5 Predictions:\nTop 1 :== Poking something so that it falls over. Prob := 55.23%\nTop 2 :== Tipping something over. Prob := 40.12%\nTop 3 :== Poking a stack of something so the stack collapses. Prob := 4.04%\nTop 4 :== Tipping something with something in it over, so something in it falls out. Prob := 0.26%\nTop 5 :== Poking something so it slightly moves. Prob := 0.12%\n" ], [ "path_to_vid = os.path.join(config[\"data_folder\"], item_id + \".webm\")\nvideo = io.open(path_to_vid, 'r+b').read()\nencoded = base64.b64encode(video)\nHTML(data='''<video alt=\"test\" controls>\n <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\" />\n </video>'''.format(encoded.decode('ascii')))", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Bar charts\nThis is 'abusing' the scatter object to create a 3d bar chart", "_____no_output_____" ] ], [ [ "import ipyvolume as ipv\nimport numpy as np", "_____no_output_____" ], [ "# set up data similar to animation notebook\n\nu_scale = 10\nNx, Ny = 30, 15\nu = np.linspace(-u_scale, u_scale, Nx)\nv = np.linspace(-u_scale, u_scale, Ny)\nx, y = np.meshgrid(u, v, indexing='ij')\nr = np.sqrt(x**2+y**2)\nx = x.flatten()\ny = y.flatten()\nr = r.flatten()\n\ntime = np.linspace(0, np.pi*2, 15)\nz = np.array([(np.cos(r + t) * np.exp(-r/5)) for t in time])\nzz = z", "_____no_output_____" ], [ "fig = ipv.figure()\ns = ipv.scatter(x, 0, y, aux=zz, marker=\"sphere\")\ndx = u[1] - u[0]\ndy = v[1] - v[0]\n# make the x and z lim half a 'box' larger\nipv.xlim(-u_scale-dx/2, u_scale+dx/2)\nipv.zlim(-u_scale-dx/2, u_scale+dx/2)\nipv.ylim(-1.2, 1.2)\nipv.show()", "_____no_output_____" ] ], [ [ "We now make boxes, that fit exactly in the volume, by giving them a size of 1, in domain coordinates (so 1 unit as read of by the x-axis etc)", "_____no_output_____" ] ], [ [ "# make the size 1, in domain coordinates (so 1 unit as read of by the x-axis etc)\ns.geo = 'box'\ns.size = 1\ns.size_x_scale = fig.scales['x']\ns.size_y_scale = fig.scales['y']\ns.size_z_scale = fig.scales['z']", "_____no_output_____" ], [ "s.shader_snippets = {'size':\n 'size_vector.y = SCALE_SIZE_Y(aux_current); '\n}\n", "_____no_output_____" ] ], [ [ "Using a shader snippet (that runs on the GPU), we set the y size equal to the aux value. However, since the box has size 1 around the origin of (0,0,0), we need to translate it up in the y direction by 0.5.", "_____no_output_____" ] ], [ [ "s.shader_snippets = {'size':\n 'size_vector.y = SCALE_SIZE_Y(aux_current) - SCALE_SIZE_Y(0.0) ; '\n}\n\ns.geo_matrix = [dx, 0, 0, 0, 0, 1, 0, 0, 0, 0, dy, 0, 0.0, 0.5, 0, 1]", "_____no_output_____" ] ], [ [ "Since we see the boxes with negative sizes inside out, we made the material double sided", "_____no_output_____" ] ], [ [ "# since we see the boxes with negative sizes inside out, we made the material double sided\ns.material.side = \"DoubleSide\"", "_____no_output_____" ], [ "# Now also include, color, which containts rgb values\ncolor = np.array([[np.cos(r + t), 1-np.abs(z[i]), 0.1+z[i]*0] for i, t in enumerate(time)])\ncolor = np.transpose(color, (0, 2, 1)) # flip the last axes\ns.color = color", "_____no_output_____" ], [ "ipv.animation_control(s, interval=200)", "_____no_output_____" ] ], [ [ "\n# Spherical bar charts", "_____no_output_____" ] ], [ [ "# Create spherical coordinates\nu = np.linspace(0, 1, Nx)\nv = np.linspace(0, 1, Ny)\nu, v = np.meshgrid(u, v, indexing='ij')\nphi = u * 2 * np.pi\ntheta = v * np.pi\nradius = 1\nxs = radius * np.cos(phi) * np.sin(theta)\nys = radius * np.sin(phi) * np.sin(theta)\nzs = radius * np.cos(theta)\nxs = xs.flatten()\nys = ys.flatten()\nzs = zs.flatten()\n", "_____no_output_____" ], [ "fig = ipv.figure()\n# we use the coordinates as the normals, and thus direction\ns = ipv.scatter(xs, ys, zs, vx=xs, vy=ys, vz=zs, aux=zz, color=color, marker=\"cylinder_hr\")\nipv.xyzlim(2)\nipv.show()", "_____no_output_____" ], [ "ipv.animation_control(s, interval=200)", "_____no_output_____" ], [ "import bqplot\n# the aux range is from -1 to 1, but if we put 0 as min, negative values will go inside\n# the max determines the 'height' of the bars\naux_scale = bqplot.LinearScale(min=0, max=5)\ns.aux_scale = aux_scale", "_____no_output_____" ], [ "s.shader_snippets = {'size':\n '''float sc = (SCALE_AUX(aux_current) - SCALE_AUX(0.0)); size_vector.y = sc;\n '''}\ns.material.side = \"DoubleSide\"\ns.size = 2\ns.geo_matrix = [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0.0, 0.5, 0, 1]", "_____no_output_____" ], [ "ipv.style.box_off()\nipv.style.axes_off()", "_____no_output_____" ] ], [ [ "[screenshot](screenshot/bars.gif)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# ReinforcementLearning: a)UCB, b)ThompsonSampling\n\n**--------------------------------------------------------------------------------------------------------------------------**\n**--------------------------------------------------------------------------------------------------------------------------**\n**--------------------------------------------------------------------------------------------------------------------------**\n**---------------------------------------------------**\n\n\n**STRUCTURE**\n\n*In this notebook, the use of two models (**Part A**: UCB and **Part B**: Thompson Sampling) for an online advertising (Click-through rate) case study is demonstrated. Both models are part of Reinforcement Learning (RL) which is a machine learning category that is focused on different types of rewards depending on the actions taken at each step of the learning process. RL algorithms are capable of learning based on their interactions with the environment, where a reward is given each time the correct decision has been taken, in contrast to the supervised ML models where the presence of labels is required.*\n\n*For this demonstration, a dataset has been generated to represent 9 web advertisements of a product on its columns(dataset features) and the user selections (dataset rows). This dataset is based on the assumption that every time a user visits this web page, a different advertisement (ADV1 - ADV9) is displayed. The goal is to apply a Reinforcement Learning algorithm that will try to learn as quickly as possible which advertisement is selected the most (click-through rate) so as to be presented when users visit the site. Initially, the models display different advertisements to each user but as the algorithms gain more information with respect to the users selections (clicks), the advertisement that leads to the highest reward is chosen to be diplayed. The difference between the 'Upper Confidence Bound' (UCB) and the 'Thompson Sampling' algorithm lies in the selection process of the next advertisement that is to be displayed. UCB is a deterministic model, whereas Thompson Sampling is based on random variation (probabilistic model). In order to evaluate their ability to choose the advertisement with the highest conversion rate for different number of samples (users), the total reward for each model is provided, together with plots presenting the number of times each advertisement has been displayed at the web page.*\n\n\n\n", "_____no_output_____" ] ], [ [ "# Importing the libraries\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nimport warnings\nimport random\nwarnings.filterwarnings('ignore')", "_____no_output_____" ], [ "# Creating the dataset by generating random values(0 & 1) with different probabilities for each 'Adv' \n# Len.Dataset=20000\nnp.random.seed(0)\ndataset={'Adv1':np.random.choice(2, 20000,p=[0.6,0.4]),\n'Adv2':np.random.choice(2, 20000,p=[0.65,0.35]),\n'Adv3':np.random.choice(2, 20000,p=[0.44,0.56]),\n'Adv4':np.random.choice(2, 20000,p=[0.6,0.4]),\n'Adv5':np.random.choice(2, 20000,p=[0.50,0.50]),\n'Adv6':np.random.choice(2, 20000,p=[0.49,0.51]),\n'Adv7':np.random.choice(2, 20000,p=[0.4,0.6]),\n'Adv8':np.random.choice(2, 20000,p=[0.52,0.48]),\n'Adv9':np.random.choice(2, 20000,p=[0.47,0.53])}\ndata=pd.DataFrame(data=dataset)", "_____no_output_____" ], [ "# Dataset-First ten records\ndata.head(10)", "_____no_output_____" ] ], [ [ "## UCB", "_____no_output_____" ] ], [ [ "#Upper Confidence Bound Algorithm\ndef ucb_rewards(Users_Num):\n #Total Number of Advertisements\n Ad_Num=9\n #List of advertisements that are selected by the algorithm based on the user clicks at each step (initially empty)\n Ad_to_Display=[]\n # Count how many times each advertisement is selected\n Ad_Cnt_Selection=[0]*Ad_Num\n # For each advertisement compute sum of its rewards (initially empty)\n Ad_Rewards=[0]*Ad_Num\n # Total number of rewards (initially zero)\n Ad_Total_Rewards=0\n \n for x in range(1,Users_Num+1): \n Ad=0\n UCB_max=0\n for j in range(0,Ad_Num):\n if Ad_Cnt_Selection[j]>0:\n Ad_Avg_Reward=Ad_Rewards[j]/Ad_Cnt_Selection[j]\n UCB= Ad_Avg_Reward + np.sqrt(3*np.log(x)/(2*Ad_Cnt_Selection[j]))\n else:# The purpose of the else statement is to ensure that all Ads are selected (in order to determine the UCB)\n UCB=1e309 \n if UCB>UCB_max:\n UCB_max=UCB\n Ad=j\n Ad_to_Display.append(Ad)\n Ad_Cnt_Selection[Ad]+=1\n Ad_Rewards[Ad]+=data.values[x-1,Ad]\n Ad_Total_Rewards+=data.values[x-1,Ad]\n return Ad_to_Display,Ad_Total_Rewards\n \n \n\n \n ", "_____no_output_____" ], [ "# The algorithm is to be executed for different samples, whose number progressively increases, so as to observe how many\n# samples were required for the model to be able to identify clearly the Ad with the highest conversion rate\nselected_Ad_2000=ucb_rewards(Users_Num=2000)\nselected_Ad_5000=ucb_rewards(Users_Num=5000)\nselected_Ad_10000=ucb_rewards(Users_Num=10000)\nselected_Ad_20000=ucb_rewards(Users_Num=20000)", "_____no_output_____" ], [ "# Conversion to pandas dataframe\ndf_selected_Ad_2000=pd.DataFrame(data=selected_Ad_2000[0],columns=['Advertisements - Users:2000'])\ndf_selected_Ad_5000=pd.DataFrame(data=selected_Ad_5000[0],columns=['Advertisements - Users:5000'])\ndf_selected_Ad_10000=pd.DataFrame(data=selected_Ad_10000[0],columns=['Advertisements - Users:10000'])\ndf_selected_Ad_20000=pd.DataFrame(data=selected_Ad_20000[0],columns=['Advertisements - Users:20000'])", "_____no_output_____" ], [ "# As it can be observed, the model managed to identify clearly the Ad with the highest conversion rate at the first 10000\n# samples, with good performance at the first 2000 & 5000 samples as well\nfig,axs=plt.subplots(2,2,figsize=(14,8))\nsns.countplot(data=df_selected_Ad_2000, x=\"Advertisements - Users:2000\",label='Users:2000',ax=axs[0,0])\nsns.countplot(data=df_selected_Ad_5000, x=\"Advertisements - Users:5000\",label='Users:5000',ax=axs[0,1])\nsns.countplot(data=df_selected_Ad_10000, x=\"Advertisements - Users:10000\",label='Users:10000',ax=axs[1,0])\nsns.countplot(data=df_selected_Ad_20000, x=\"Advertisements - Users:20000\",label='Users:20000',ax=axs[1,1])\nfor ax in axs.flat:\n fig.suptitle(\"Displayed Advertisements - Upper Confidence Bound\", fontweight='bold',fontsize=18)\n ax.set_xlabel('Advertisements',fontsize=12,fontweight='bold')\n ax.set_ylabel('Count',fontsize=12,fontweight='bold')\n ax.legend()\n ax.figure.tight_layout(pad=2);\n ", "_____no_output_____" ] ], [ [ "## Thompson Sampling", "_____no_output_____" ] ], [ [ "#Thompson Sampling Algorithm\ndef TSampling_rewards(Users_Num):\n #Total Number of Advertisements\n Ad_Num=9\n #List of advertisements that are selected by the algorithm based on the user clicks at each step (initially empty)\n Ad_to_Display=[]\n # Count each time an advertisement gets reward=1\n Ad_Count_Reward_1=[0]*Ad_Num\n # Count each time an advertisement gets reward=0\n Ad_Count_Reward_0=[0]*Ad_Num\n # Total number of rewards (initially zero)\n Ad_Total_Rewards=0\n \n for x in range(1,Users_Num+1):\n Ad=0\n draw_max=0\n for j in range(0,Ad_Num):\n draw_rndm=random.betavariate(Ad_Count_Reward_1[j]+1,Ad_Count_Reward_0[j]+1)\n if draw_rndm>draw_max:\n draw_max=draw_rndm\n Ad=j\n \n Ad_to_Display.append(Ad)\n Tsample_reward = data.values[x-1, Ad]\n if Tsample_reward == 1:\n Ad_Count_Reward_1[Ad]+= 1\n else:\n Ad_Count_Reward_0[Ad]+= 1\n Ad_Total_Rewards+= Tsample_reward\n \n \n \n return Ad_to_Display,Ad_Total_Rewards\n ", "_____no_output_____" ], [ "# The algorithm is to be executed for different samples, whose number progressively increases, so as to observe how many\n# samples were required for the model to be able to identify clearly the Ad with the highest conversion rate\nselect_Ad_2000=TSampling_rewards(Users_Num=2000)\nselect_Ad_5000=TSampling_rewards(Users_Num=5000)\nselect_Ad_10000=TSampling_rewards(Users_Num=10000)\nselect_Ad_20000=TSampling_rewards(Users_Num=20000)", "_____no_output_____" ], [ "# Conversion to pandas dataframe\ndf_select_Ad_2000=pd.DataFrame(data=select_Ad_2000[0],columns=['Advertisements - Users:2000'])\ndf_select_Ad_5000=pd.DataFrame(data=select_Ad_5000[0],columns=['Advertisements - Users:5000'])\ndf_select_Ad_10000=pd.DataFrame(data=select_Ad_10000[0],columns=['Advertisements - Users:10000'])\ndf_select_Ad_20000=pd.DataFrame(data=select_Ad_20000[0],columns=['Advertisements - Users:20000'])", "_____no_output_____" ], [ "# As it can be observed, the Thompson Sampling algorithm managed to outperform UCB as it has clearly identified the Ad with\n# the highest conversion rate at the first 5000 samples, with almost excellent performance at the first 2000 samples as well\nfig,axs=plt.subplots(2,2,figsize=(14,8))\nsns.countplot(data=df_select_Ad_2000, x=\"Advertisements - Users:2000\",label='Users:2000',ax=axs[0,0])\nsns.countplot(data=df_select_Ad_5000, x=\"Advertisements - Users:5000\",label='Users:5000',ax=axs[0,1])\nsns.countplot(data=df_select_Ad_10000, x=\"Advertisements - Users:10000\",label='Users:10000',ax=axs[1,0])\nsns.countplot(data=df_select_Ad_20000, x=\"Advertisements - Users:20000\",label='Users:20000',ax=axs[1,1])\n\nfor ax in axs.flat:\n fig.suptitle(\"Displayed Advertisements - Thompson Sampling\", fontweight='bold',fontsize=18)\n ax.set_xlabel('Advertisements',fontsize=12,fontweight='bold')\n ax.set_ylabel('Count',fontsize=12,fontweight='bold')\n ax.legend()\n ax.figure.tight_layout(pad=2);", "_____no_output_____" ], [ "# Total rewards for selected data samples\n\nUCB_total_rewards2000=selected_Ad_2000[1]\nUCB_total_rewards5000=selected_Ad_5000[1]\nUCB_total_rewards10000=selected_Ad_10000[1]\nUCB_total_rewards20000=selected_Ad_20000[1]\nprint('UCB Total Rewards 2000 samples: {}'.format(UCB_total_rewards2000))\nprint('UCB Total Rewards 5000 samples: {}'.format(UCB_total_rewards5000))\nprint('UCB Total Rewards 10000 samples: {}'.format(UCB_total_rewards10000))\nprint('UCB Total Rewards 20000 samples: {}'.format(UCB_total_rewards20000))\nprint('\\r')\nTSampling_total_rewards2000=select_Ad_2000[1]\nTSampling_total_rewards5000=select_Ad_5000[1]\nTSampling_total_rewards10000=select_Ad_10000[1]\nTSampling_total_rewards20000=select_Ad_20000[1]\nprint('TSampling Total Rewards 2000 samples: {}'.format(TSampling_total_rewards2000))\nprint('TSampling Total Rewards 5000 samples: {}'.format(TSampling_total_rewards5000))\nprint('TSampling Total Rewards 10000 samples: {}'.format(TSampling_total_rewards10000))\nprint('TSampling Total Rewards 20000 samples: {}'.format(TSampling_total_rewards20000))", "UCB Total Rewards 2000 samples: 1082\nUCB Total Rewards 5000 samples: 2738\nUCB Total Rewards 10000 samples: 5588\nUCB Total Rewards 20000 samples: 11402\n\r\nTSampling Total Rewards 2000 samples: 1148\nTSampling Total Rewards 5000 samples: 2937\nTSampling Total Rewards 10000 samples: 5904\nTSampling Total Rewards 20000 samples: 11954\n" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Emukit tutorials\n\nEmukit tutorials can be added and used through the links below. The goal of each of these tutorials is to explain a particular functionality of the Emukit project. These tutorials are stand-alone notebooks that don't require any extra files and fully sit on Emukit components (apart from the creation of the model).\n\nSome tutorials have been written with the purpose of explaining some scientific concepts and can be used for learning about different topics in emulation and uncertainty quantification. Other tutorials are a small guide to describe some feature of the library.\n\nAnother great resource to learn Emukit are the [examples](../emukit/examples) which are more elaborated modules focused either on the implementation of a new method with Emukit components or on the analysis and solution of some specific problem.", "_____no_output_____" ], [ "### Getting Started\n\nTutorials in this section will get you up and running with Emukit as quickly as possible.\n\n* [5 minutes introduction to Emukit](Emukit-tutorial-intro.ipynb)\n* [Philosophy and Basic use of the library](Emukit-tutorial-basic-use-of-the-library.ipynb)", "_____no_output_____" ], [ "### Scientific tutorials\n\nTutorials in this section will teach you about the theoretical foundations of surrogate optimization using Emukit.\n* [Introduction to Bayesian optimization](Emukit-tutorial-Bayesian-optimization-introduction.ipynb)\n* [Introduction to multi-fidelity Gaussian processes](Emukit-tutorial-multi-fidelity.ipynb)\n* [Introduction to sensitivity analysis](Emukit-tutorial-sensitivity-montecarlo.ipynb)\n* [Introduction to Bayesian Quadrature](Emukit-tutorial-Bayesian-quadrature-introduction.ipynb)\n* [Introduction to Experimental Design](Emukit-tutorial-experimental-design-introduction.ipynb)", "_____no_output_____" ], [ "### Features tutorials\n\nTutorials in this section will give you code snippets and explanations of various practical features included in the Emukit project.\n* [Bayesian optimization with external evaluation of the objective](Emukit-tutorial-bayesian-optimization-external-objective-evaluation.ipynb)\n* [Bayesian optimization with context variables](Emukit-tutorial-bayesian-optimization-context-variables.ipynb)\n* [Learn how to to combine an acquisition function (entropy search) with a multi-source (fidelity) Gaussian process](Emukit-tutorial-multi-fidelity-bayesian-optimization.ipynb)\n* [How to benchmark several Bayesian optimization methods with Emukit](Emukit-tutorial-bayesian-optimization-benchmark.ipynb)\n* [How to perform Bayesian optimization with non-linear constraints](Emukit-tutorial-constrained-optimization.ipynb)\n* [Bayesian optimization integrating the hyper-parameters of the model](Emukit-tutorial-bayesian-optimization-integrating-model-hyperparameters.ipynb)\n* [How to use custom model](Emukit-tutorial-custom-model.ipynb)\n* [How to select neural network hyperparameters: categorical variables in Emukit](Emukit-tutorial-select-neural-net-hyperparameters.ipynb)\n* [How to parallelize external objective function evaluations in Bayesian optimization](Emukit-tutorial-parallel-eval-of-obj-fun.ipynb)", "_____no_output_____" ], [ "## Contribution guide\n\nCommunity contributions are vital to the success of any open source project. [Tutorials](Emukit-tutorial-how-to-write-a-notebook.ipynb) and [examples](https://github.com/emukit/emukit/tree/main/emukit/examples) are a great way to spread what you have learned about Emukit across the community and an excellent way to showcase new features. If you want to contribute with a new tutorial please follow [these steps](Emukit-tutorial-how-to-write-a-notebook.ipynb).\n\nWe also welcome feedback, so if there is any aspect of Emukit that we can improve, please [raise an issue](https://github.com/EmuKit/emukit/issues/new)!", "_____no_output_____" ] ] ]

[ "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import sys\nsys.path.insert(1, '../')\nimport resonance", "_____no_output_____" ], [ "res_obj = resonance.ResonanceKid(filename=\"../data/resonance01.txt\")", "_____no_output_____" ], [ "res_obj.plot_fit()", "No fit found: doing it now\n" ], [ "res_obj.fit()", "_____no_output_____" ], [ "print(\"Last fit Chi2: \", res_obj.chi2)", "Last fit Chi2: 0.3265423634975578\n" ], [ "res_obj.plot_phase()", "_____no_output_____" ], [ "res_obj.plot_amp()", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "%run ../setup/nb_setup\n%matplotlib inline", "_____no_output_____" ] ], [ [ "# Compute a Galactic orbit for a star using Gaia data\n\nAuthor(s): Adrian Price-Whelan\n\n\n## Learning goals\n\nIn this tutorial, we will retrieve the sky coordinates, astrometry, and radial velocity for a star — [Kepler-444](https://en.wikipedia.org/wiki/Kepler-444) — and compute its orbit in the default Milky Way mass model implemented in Gala. We will compare the orbit of Kepler-444 to the orbit of the Sun and a random sample of nearby stars.\n\n\n### Notebook Setup and Package Imports", "_____no_output_____" ] ], [ [ "import astropy.coordinates as coord\nimport astropy.units as u\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom mpl_toolkits.mplot3d import Axes3D\nfrom pyia import GaiaData\n\n# Gala\nimport gala.dynamics as gd\nimport gala.potential as gp", "_____no_output_____" ] ], [ [ "## Define a Galactocentric Coordinate Frame\n\nWe will start by defining a Galactocentric coordinate system using `astropy.coordinates`. We will adopt the latest parameter set assumptions for the solar Galactocentric position and velocity as implemented in Astropy, but note that these parameters are customizable by passing parameters into the `Galactocentric` class below (e.g., you could change the sun-galactic center distance by setting `galcen_distance=...`).", "_____no_output_____" ] ], [ [ "with coord.galactocentric_frame_defaults.set(\"v4.0\"):\n galcen_frame = coord.Galactocentric()\ngalcen_frame", "_____no_output_____" ] ], [ [ "## Define the Solar Position and Velocity", "_____no_output_____" ], [ "In this coordinate system, the sun is along the $x$-axis (at a negative $x$ value), and the Galactic rotation at this position is in the $+y$ direction. The 3D position of the sun is therefore given by:", "_____no_output_____" ] ], [ [ "sun_xyz = u.Quantity(\n [-galcen_frame.galcen_distance, 0 * u.kpc, galcen_frame.z_sun] # x,y,z\n)", "_____no_output_____" ] ], [ [ "We can combine this with the solar velocity vector (defined in the `astropy.coordinates.Galactocentric` frame) to define the sun's phase-space position, which we will use as initial conditions shortly to compute the orbit of the Sun:", "_____no_output_____" ] ], [ [ "sun_vxyz = galcen_frame.galcen_v_sun\nsun_vxyz", "_____no_output_____" ], [ "sun_w0 = gd.PhaseSpacePosition(pos=sun_xyz, vel=sun_vxyz)", "_____no_output_____" ] ], [ [ "To compute the sun's orbit, we need to specify a mass model for the Galaxy. Here, we will use the default Milky Way mass model implemented in Gala, which is defined in detail in the Gala documentation: [Defining a Milky Way model](define-milky-way-model.html). Here, we will initialize the potential model with default parameters:", "_____no_output_____" ] ], [ [ "mw_potential = gp.MilkyWayPotential()\nmw_potential", "_____no_output_____" ] ], [ [ "This potential is composed of four mass components meant to represent simple models of the different structural components of the Milky Way:", "_____no_output_____" ] ], [ [ "for k, pot in mw_potential.items():\n print(f\"{k}: {pot!r}\")", "_____no_output_____" ] ], [ [ "With a potential model for the Galaxy and initial conditions for the sun, we can now compute the Sun's orbit using the default integrator (Leapfrog integration): We will compute the orbit for 4 Gyr, which is about 16 orbital periods.", "_____no_output_____" ] ], [ [ "sun_orbit = mw_potential.integrate_orbit(sun_w0, dt=0.5 * u.Myr, t1=0, t2=4 * u.Gyr)", "_____no_output_____" ] ], [ [ "Let's plot the Sun's orbit in 3D to get a feel for the geometry of the orbit:", "_____no_output_____" ] ], [ [ "fig, ax = sun_orbit.plot_3d()\n\nlim = (-12, 12)\nax.set(xlim=lim, ylim=lim, zlim=lim)", "_____no_output_____" ] ], [ [ "## Retrieve Gaia Data for Kepler-444", "_____no_output_____" ], [ "As a comparison, we will compute the orbit of the exoplanet-hosting star \"Kepler-444.\" To get Gaia data for this star, we first have to retrieve its sky coordinates so that we can do a positional cross-match query on the Gaia catalog. We can retrieve the sky position of Kepler-444 from Simbad using the `SkyCoord.from_name()` classmethod, which queries Simbad under the hood to resolve the name:", "_____no_output_____" ] ], [ [ "star_sky_c = coord.SkyCoord.from_name(\"Kepler-444\")\nstar_sky_c", "_____no_output_____" ] ], [ [ "We happen to know a priori that Kepler-444 has a large proper motion, so the sky position reported by Simbad could be off from the Gaia sky position (epoch=2016) by many arcseconds. To run and retrieve the Gaia data, we will use the [pyia](http://pyia.readthedocs.io/) package: We can pass in an ADQL query, which `pyia` uses to query the Gaia science archive using `astroquery`, and returns the data as a `pyia.GaiaData` object. To run the query, we will do a sky position cross-match with a large positional tolerance by setting the cross-match radius to 15 arcseconds, but we will take the brightest cross-matched source within this region as our match:", "_____no_output_____" ] ], [ [ "star_gaia = GaiaData.from_query(\n f\"\"\"\n SELECT TOP 1 * FROM gaiaedr3.gaia_source\n WHERE 1=CONTAINS(\n POINT('ICRS', {star_sky_c.ra.degree}, {star_sky_c.dec.degree}),\n CIRCLE('ICRS', ra, dec, {(15*u.arcsec).to_value(u.degree)})\n )\n ORDER BY phot_g_mean_mag\n \"\"\"\n)\nstar_gaia", "_____no_output_____" ] ], [ [ "We will assume (and hope!) that this source is Kepler-444, but we know that it is fairly bright compared to a typical Gaia source, so we should be safe.\n\nWe can now use the returned `pyia.GaiaData` object to retrieve an astropy `SkyCoord` object with all of the position and velocity measurements taken from the Gaia archive record for this source:", "_____no_output_____" ] ], [ [ "star_gaia_c = star_gaia.get_skycoord()\nstar_gaia_c", "_____no_output_____" ] ], [ [ "To compute this star's Galactic orbit, we need to convert its observed, Heliocentric (actually solar system barycentric) data into the Galactocentric coordinate frame we defined above. To do this, we will use the `astropy.coordinates` transformation framework using the `.transform_to()` method, and we will pass in the `Galactocentric` coordinate frame we defined above:", "_____no_output_____" ] ], [ [ "star_galcen = star_gaia_c.transform_to(galcen_frame)\nstar_galcen", "_____no_output_____" ] ], [ [ "Let's print out the Cartesian position and velocity for Kepler-444:", "_____no_output_____" ] ], [ [ "print(star_galcen.cartesian)\nprint(star_galcen.velocity)", "_____no_output_____" ] ], [ [ "Now with Galactocentric position and velocity components for Kepler-444, we can create Gala initial conditions and compute its orbit on the time grid used to compute the Sun's orbit above:", "_____no_output_____" ] ], [ [ "star_w0 = gd.PhaseSpacePosition(star_galcen.data)\nstar_orbit = mw_potential.integrate_orbit(star_w0, t=sun_orbit.t)", "_____no_output_____" ] ], [ [ "We can now compare the orbit of Kepler-444 to the solar orbit we computed above. We will plot the two orbits in two projections: First in the $x$-$y$ plane (Cartesian positions), then in the *meridional plane*, showing the cylindrical $R$ and $z$ position dependence of the orbits:", "_____no_output_____" ] ], [ [ "fig, axes = plt.subplots(1, 2, figsize=(10, 5), constrained_layout=True)\n\nsun_orbit.plot([\"x\", \"y\"], axes=axes[0])\nstar_orbit.plot([\"x\", \"y\"], axes=axes[0])\naxes[0].set_xlim(-10, 10)\naxes[0].set_ylim(-10, 10)\n\nsun_orbit.cylindrical.plot(\n [\"rho\", \"z\"],\n axes=axes[1],\n auto_aspect=False,\n labels=[\"$R$ [kpc]\", \"$z$ [kpc]\"],\n label=\"Sun\",\n)\nstar_orbit.cylindrical.plot(\n [\"rho\", \"z\"],\n axes=axes[1],\n auto_aspect=False,\n labels=[\"$R$ [kpc]\", \"$z$ [kpc]\"],\n label=\"Kepler-444\",\n)\naxes[1].set_xlim(0, 10)\naxes[1].set_ylim(-5, 5)\naxes[1].set_aspect(\"auto\")\naxes[1].legend(loc=\"best\", fontsize=15)", "_____no_output_____" ] ], [ [ "### Exercise: How does Kepler-444's orbit differ from the Sun's?\n\n- What are the guiding center radii of the two orbits? \n- What is the maximum $z$ height reached by each orbit? \n- What are their eccentricities? \n- Can you guess which star is older based on their kinematics? \n- Which star do you think has a higher metallicity?", "_____no_output_____" ], [ "### Exercise: Compute orbits for Monte Carlo sampled initial conditions using the Gaia error distribution\n\n*Hint: Use the `pyia.GaiaData.get_error_samples()` method to generate samples from the Gaia error distribution*\n\n- Generate 128 samples from the error distribution\n- Construct a `SkyCoord` object with all of these Monte Carlo samples \n- Transform the error sample coordinates to the Galactocentric frame and define Gala initial conditions (a `PhaseSpacePosition` object)\n- Compute orbits for all error samples using the same time grid we used above\n- Compute the eccentricity and $L_z$ for all samples: what is the standard deviation of the eccentricity and $L_z$ values? \n- With what fractional precision can we measure this star's eccentricity and $L_z$? (i.e. what is $\\textrm{std}(e) / \\textrm{mean}(e)$ and the same for $L_z$)", "_____no_output_____" ], [ "### Exercise: Comparing these orbits to the orbits of other Gaia stars\n\nRetrieve Gaia data for a set of 100 random Gaia stars within 200 pc of the sun with measured radial velocities and well-measured parallaxes using the query:\n\n SELECT TOP 100 * FROM gaiaedr3.gaia_source \n WHERE dr2_radial_velocity IS NOT NULL AND\n parallax_over_error > 10 AND\n ruwe < 1.2 AND\n parallax > 5\n ORDER BY random_index", "_____no_output_____" ] ], [ [ "# random_stars_g = ..", "_____no_output_____" ] ], [ [ "Compute orbits for these stars for the same time grid used above to compute the sun's orbit:", "_____no_output_____" ] ], [ [ "# random_stars_c = ...", "_____no_output_____" ], [ "# random_stars_galcen = ...\n# random_stars_w0 = ...", "_____no_output_____" ], [ "# random_stars_orbits = ...", "_____no_output_____" ] ], [ [ "Plot the initial (present-day) positions of all of these stars in Galactocentric Cartesian coordinates:", "_____no_output_____" ], [ "Now plot the orbits of these stars in the x-y and R-z planes:", "_____no_output_____" ] ], [ [ "fig, axes = plt.subplots(1, 2, figsize=(10, 5), constrained_layout=True)\n\nrandom_stars_orbits.plot([\"x\", \"y\"], axes=axes[0])\naxes[0].set_xlim(-15, 15)\naxes[0].set_ylim(-15, 15)\n\nrandom_stars_orbits.cylindrical.plot(\n [\"rho\", \"z\"],\n axes=axes[1],\n auto_aspect=False,\n labels=[\"$R$ [kpc]\", \"$z$ [kpc]\"],\n)\n\naxes[1].set_xlim(0, 15)\naxes[1].set_ylim(-5, 5)\naxes[1].set_aspect(\"auto\")", "_____no_output_____" ] ], [ [ "Compute maximum $z$ heights ($z_\\textrm{max}$) and eccentricities for all of these orbits. Compare the Sun, Kepler-444, and this random sampling of nearby stars. Where do the Sun and Kepler-444 sit relative to the random sample of nearby stars in terms of $z_\\textrm{max}$ and eccentricity? (Hint: plot $z_\\textrm{max}$ vs. eccentricity and highlight the Sun and Kepler-444!) Are either of them outliers in any way?", "_____no_output_____" ] ], [ [ "# rand_zmax = ...", "_____no_output_____" ], [ "# rand_ecc = ...", "_____no_output_____" ], [ "fig, ax = plt.subplots(figsize=(8, 6))\nax.scatter(\n rand_ecc, rand_zmax, color=\"k\", alpha=0.4, s=14, lw=0, label=\"random nearby stars\"\n)\nax.scatter(sun_orbit.eccentricity(), sun_orbit.zmax(), color=\"tab:orange\", label=\"Sun\")\nax.scatter(\n star_orbit.eccentricity(), star_orbit.zmax(), color=\"tab:cyan\", label=\"Kepler-444\"\n)\nax.legend(loc=\"best\", fontsize=14)\nax.set_xlabel(\"eccentricity, $e$\")\nax.set_ylabel(r\"max. $z$ height, $z_{\\rm max}$ [kpc]\")", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import os\nimport tarfile\nimport urllib", "_____no_output_____" ], [ "DOWNLOAD_ROOT = \"https://raw.githubusercontent.com/ageron/handson-ml2/master/\"\nHOUSING_PATH = os.path.join(\"datasets\",\"housing\")\nHOUSING_URL = DOWNLOAD_ROOT + \"datasets/housing/housing.tgz\"", "_____no_output_____" ], [ "def fetch_housing_data(housing_url = HOUSING_URL,housing_path = HOUSING_PATH):\n os.makedirs(housing_path,exist_ok=True)\n tgz_path = os.path.join(housing_path,\"housing.tgz\")\n urllib.request.urlretrieve(housing_url, tgz_path)\n housing_tgz = tarfile.open(tgz_path)\n housing_tgz.extractall(path=housing_path)\n housing_tgz.close()", "_____no_output_____" ], [ "fetch_housing_data()", "_____no_output_____" ], [ "import pandas as pd", "_____no_output_____" ], [ "def load_housing_data(housing_path = HOUSING_PATH):\n csv_path = os.path.join(housing_path,\"housing.csv\")\n return pd.read_csv(csv_path)", "_____no_output_____" ], [ "housing = load_housing_data()", "_____no_output_____" ], [ "housing.head()", "_____no_output_____" ], [ "housing.info()", "<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 20640 entries, 0 to 20639\nData columns (total 10 columns):\nlongitude 20640 non-null float64\nlatitude 20640 non-null float64\nhousing_median_age 20640 non-null float64\ntotal_rooms 20640 non-null float64\ntotal_bedrooms 20433 non-null float64\npopulation 20640 non-null float64\nhouseholds 20640 non-null float64\nmedian_income 20640 non-null float64\nmedian_house_value 20640 non-null float64\nocean_proximity 20640 non-null object\ndtypes: float64(9), object(1)\nmemory usage: 1.6+ MB\n" ], [ "housing[\"ocean_proximity\"].value_counts()", "_____no_output_____" ], [ "housing.describe()", "_____no_output_____" ], [ "import matplotlib.pyplot as plt\n%matplotlib inline", "_____no_output_____" ], [ "housing.hist(bins=50, figsize=(20,15))\nplt.show()", "_____no_output_____" ], [ "import numpy as np", "_____no_output_____" ], [ "def split_test_data(data,test_ratio):\n shuffled_indices = np.random.permutation(len(data))\n test_set_size = int(len(data)*test_ratio)\n test_indices = shuffled_indices[:test_set_size]\n train_indices = shuffled_indices[test_set_size:]\n return data.iloc[train_indices], data.iloc[test_indices]", "_____no_output_____" ], [ "train_set, test_set = split_test_data(housing,0.2)", "_____no_output_____" ], [ "len(train_set)", "_____no_output_____" ], [ "len(test_set)", "_____no_output_____" ], [ "from zlib import crc32", "_____no_output_____" ], [ "def test_set_check(identifier, test_ratio):\n return crc32(np.int64(identifier)) & 0xffffffff < test_ratio * 2**32", "_____no_output_____" ], [ "def split_train_test_by_id(data, test_ratio, id_column):\n ids = data[id_column]\n in_test_set = ids.apply(lambda id_ : test_set_check(id_ , test_ratio))\n return data.loc[~in_test_set], data.loc[in_test_set]", "_____no_output_____" ], [ "housing_with_id = housing.reset_index()\ntrain_set, test_set = split_train_test_by_id(housing_with_id,0.2,\"index\")", "_____no_output_____" ], [ "housing_with_id[\"id\"] = housing[\"longitude\"] * 1000 + housing[\"latitude\"]\ntrain_set, test_set = split_train_test_by_id(housing_with_id,0.2,\"id\")", "_____no_output_____" ], [ "from sklearn.model_selection import train_test_split", "_____no_output_____" ], [ "train_set, test_set = train_test_split(housing,test_size = 0.2, random_state = 42)", "_____no_output_____" ], [ "housing[\"income_cat\"] = pd.cut(housing[\"median_income\"],bins=[0.,1.5,3.0,4.5,6.,np.inf],labels=[1,2,3,4,5])", "_____no_output_____" ], [ "housing[\"income_cat\"].hist()", "_____no_output_____" ], [ "from sklearn.model_selection import StratifiedShuffleSplit", "_____no_output_____" ], [ "split = StratifiedShuffleSplit(n_splits = 1,test_size=0.2,random_state=42)\nfor train_index, test_index in split.split(housing,housing[\"income_cat\"]):\n strat_train_set = housing.loc[train_index]\n strat_test_set = housing.loc[test_index]", "_____no_output_____" ], [ "strat_test_set[\"income_cat\"].value_counts()/len(strat_test_set)", "_____no_output_____" ], [ "strat_train_set[\"income_cat\"].value_counts()/len(strat_train_set)", "_____no_output_____" ], [ "for set_ in (strat_train_set,strat_test_set):\n set_.drop(\"income_cat\",axis=1,inplace=True)", "_____no_output_____" ], [ "housing = strat_train_set.copy()", "_____no_output_____" ], [ "housing.plot(kind=\"scatter\",x=\"longitude\",y=\"latitude\")", "_____no_output_____" ], [ "housing.plot(kind=\"scatter\",x=\"longitude\",y=\"latitude\",alpha=0.1)", "_____no_output_____" ], [ "housing.plot(kind=\"scatter\",x=\"longitude\",y=\"latitude\",alpha=0.4,s=housing[\"population\"]/100,label = \"population\",figsize =(10,7),c=\"median_house_value\",cmap=plt.get_cmap(\"jet\"),colorbar=True)\nplt.legend()", "_____no_output_____" ], [ "housing.plot(kind=\"scatter\",x=\"longitude\",y=\"latitude\",alpha=0.4,s=housing[\"population\"]/100,label = \"population\",figsize =(10,7),c=\"median_house_value\",cmap=plt.get_cmap(\"jet\"),colorbar=True)\nplt.legend()", "_____no_output_____" ], [ "corr_matrix = housing.corr()", "_____no_output_____" ], [ "corr_matrix[\"median_house_value\"].sort_values(ascending=False)", "_____no_output_____" ], [ "corr_matrix", "_____no_output_____" ], [ "from pandas.plotting import scatter_matrix", "_____no_output_____" ], [ "attributes = [\"median_house_value\",\"median_income\",\"total_rooms\",\"housing_median_age\"]", "_____no_output_____" ], [ "scatter_matrix(housing[attributes],figsize=(12,8))", "_____no_output_____" ], [ "housing.plot(kind=\"scatter\",x=\"median_income\",y=\"median_house_value\",alpha = 0.1)", "_____no_output_____" ], [ "housing[\"rooms_per_household\"] = housing[\"total_rooms\"]/housing[\"households\"]\nhousing[\"bedrooms_per_room\"] = housing[\"total_bedrooms\"]/housing[\"total_rooms\"]\nhousing[\"population_per_household\"] = housing[\"population\"]/housing[\"households\"]", "_____no_output_____" ], [ "corr_matrix = housing.corr()\ncorr_matrix[\"median_house_value\"].sort_values(ascending=False)", "_____no_output_____" ], [ "housing = strat_train_set.drop(\"median_house_value\",axis=1)\nhousing_labels = strat_train_set[\"median_house_value\"].copy()", "_____no_output_____" ], [ "# housing.dropna(subset=[\"total_bedrooms\"]) //option 1\n# housing.drop(\"total_bedrooms\",axis=1) //option 2\nmedian = housing[\"total_bedrooms\"].median() #//option 3\nhousing[\"total_bedrooms\"].fillna(median,inplace=True)", "_____no_output_____" ], [ "from sklearn.impute import SimpleImputer\nimputer = SimpleImputer(strategy=\"median\")", "_____no_output_____" ], [ "housing_num = housing.drop(\"ocean_proximity\",axis=1)", "_____no_output_____" ], [ "imputer.fit(housing_num)", "_____no_output_____" ], [ "imputer.statistics_", "_____no_output_____" ], [ "housing_num.median().values", "_____no_output_____" ], [ "X = imputer.transform(housing_num)", "_____no_output_____" ], [ "housing_tr = pd.DataFrame(X,columns=housing_num.columns,index=housing_num.index)", "_____no_output_____" ], [ "housing_cat = housing[[\"ocean_proximity\"]]\nhousing_cat.head(10)", "_____no_output_____" ], [ "from sklearn.preprocessing import OrdinalEncoder\nordinal_encoder = OrdinalEncoder()\nhousing_cat_encoded = ordinal_encoder.fit_transform(housing_cat)\nhousing_cat_encoded[0:10]", "_____no_output_____" ], [ "ordinal_encoder.categories_", "_____no_output_____" ], [ "from sklearn.preprocessing import OneHotEncoder\ncat_encoder = OneHotEncoder()\nhousing_cat_1hot = cat_encoder.fit_transform(housing_cat)\nhousing_cat_1hot", "_____no_output_____" ], [ "housing_cat_1hot.toarray()", "_____no_output_____" ], [ "cat_encoder.categories_", "_____no_output_____" ], [ "from sklearn.base import BaseEstimator, TransformerMixin", "_____no_output_____" ], [ "rooms_ix, bedrooms_ix, population_ix, households_ix = 3,4,5,6", "_____no_output_____" ], [ "class CombinedAttributesAdder(BaseEstimator,TransformerMixin):\n def __init__(self,add_bedrooms_per_room=True):\n self.add_bedrooms_per_room = add_bedrooms_per_room\n \n def fit(self,X,y=None):\n return self\n \n def transform(self,X,y=None):\n rooms_per_households = X[:,rooms_ix]/X[:,households_ix]\n population_per_household = X[:,population_ix]/X[:,households_ix]\n if self.add_bedrooms_per_room:\n bedrooms_per_room = X[:,bedrooms_ix]/X[:,rooms_ix]\n return np.c_[X,rooms_per_households,population_per_household,bedrooms_per_room]\n else:\n return np.c_[X,rooms_per_households,population_per_household]\n \nattr_adder = CombinedAttributesAdder(add_bedrooms_per_room=False)\nhousing_extra_attribs = attr_adder.transform(housing.values)", "_____no_output_____" ], [ "from sklearn.pipeline import Pipeline\nfrom sklearn.preprocessing import StandardScaler\nnum_pipeine = Pipeline([('imputer',SimpleImputer(strategy=\"median\")),(\"attribs_adder\",CombinedAttributesAdder()),(\"std_scaler\",StandardScaler())])\nhousing_num_tr = num_pipeine.fit_transform(housing_num)", "_____no_output_____" ], [ "from sklearn.compose import ColumnTransformer\nnum_attribs = list(housing_num)\ncat_attribs = [\"ocean_proximity\"]\nfull_pipeline = ColumnTransformer([(\"num\",num_pipeine,num_attribs),(\"cat\",OneHotEncoder(),cat_attribs)])\nhousing_prepared = full_pipeline.fit_transform(housing)", "_____no_output_____" ], [ "from sklearn.linear_model import LinearRegression\nlin_reg = LinearRegression()\nlin_reg.fit(housing_prepared, housing_labels)", "_____no_output_____" ], [ "some_data = housing.iloc[:5]\nsome_labels = housing_labels.iloc[:5]\nsome_data_prepared = full_pipeline.transform(some_data)\nprint(\"Predictions:\",lin_reg.predict(some_data_prepared))\nprint(\"Labels:\",list(some_labels))", "Predictions: [210644.60459286 317768.80697211 210956.43331178 59218.98886849\n 189747.55849879]\nLabels: [286600.0, 340600.0, 196900.0, 46300.0, 254500.0]\n" ], [ "from sklearn.metrics import mean_squared_error\nhousing_predictions = lin_reg.predict(housing_prepared)\nlin_mse = mean_squared_error(housing_labels,housing_predictions)\nlin_rmse = np.sqrt(lin_mse)\nprint(lin_rmse)", "68628.19819848922\n" ], [ "from sklearn.model_selection import cross_val_score\nfrom sklearn.tree import DecisionTreeRegressor\ntree_reg = DecisionTreeRegressor()\ntree_reg.fit(housing_prepared,housing_labels)\nhousing_predictions = tree_reg.predict(housing_prepared)\ntree_mse = mean_squared_error(housing_labels, housing_predictions)\ntree_rmse = np.sqrt(tree_mse)\ntree_rmse", "_____no_output_____" ], [ "scores = cross_val_score(tree_reg, housing_prepared,housing_labels,scoring=\"neg_mean_squared_error\",cv=10)\ntree_rmse_scores = np.sqrt(-scores)", "_____no_output_____" ], [ "def display_scores(scores):\n print(\"Scores:\",scores)\n print(\"Mean:\",scores.mean())\n print(\"Standard deviation:\",scores.std())\ndisplay_scores(tree_rmse_scores)", "Scores: [68264.58632794 66832.02566438 70984.75467681 69766.2729475\n 71429.50148006 75290.54803507 70553.58788847 72351.24063877\n 76364.90662642 68927.4177411 ]\nMean: 71076.48420265231\nStandard deviation: 2828.6842149131676\n" ], [ "lin_scores = cross_val_score(lin_reg,housing_prepared,housing_labels,scoring=\"neg_mean_squared_error\",cv=10)\nlin_rmse_scores = np.sqrt(-lin_scores)\ndisplay_scores(lin_rmse_scores)", "Scores: [66782.73843989 66960.118071 70347.95244419 74739.57052552\n 68031.13388938 71193.84183426 64969.63056405 68281.61137997\n 71552.91566558 67665.10082067]\nMean: 69052.46136345083\nStandard deviation: 2731.674001798348\n" ], [ "from sklearn.ensemble import RandomForestRegressor\nforest_reg = RandomForestRegressor()\nforest_reg.fit(housing_prepared,housing_labels)\nhousing_predictions = forest_reg.predict(housing_prepared)\nforest_mse = mean_squared_error(housing_labels,housing_predictions)\nforest_rmse = np.sqrt(forest_mse)\nprint(forest_rmse)\nforest_scores = cross_val_score(forest_reg,housing_prepared,housing_labels,scoring=\"neg_mean_squared_error\",cv=10)\nforest_rmse_scores = np.sqrt(-forest_scores)\ndisplay_scores(forest_rmse_scores)", "18616.024716061336\nScores: [49101.84709414 47627.20374801 49933.62977321 52464.36121838\n 49878.78526325 53573.7375593 48850.97811029 47606.5883449\n 52885.34168166 50151.58707814]\nMean: 50207.405987128644\nStandard deviation: 2006.6710879860314\n" ], [ "# imp+", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Image Denoising with Autoencoders\n\n## Introduction and Importing Libraries\n___\nNote: If you are starting the notebook from this task, you can run cells from all previous tasks in the kernel by going to the top menu and then selecting Kernel > Restart and Run All\n___", "_____no_output_____" ] ], [ [ "import numpy as np\n\nfrom tensorflow.keras.datasets import mnist\nfrom matplotlib import pyplot as plt\nfrom tensorflow.keras.models import Sequential, Model\nfrom tensorflow.keras.layers import Dense, Input\nfrom tensorflow.keras.callbacks import EarlyStopping, LambdaCallback\nfrom tensorflow.keras.utils import to_categorical\n\n%matplotlib inline", "_____no_output_____" ] ], [ [ "## Data Preprocessing\n___\nNote: If you are starting the notebook from this task, you can run cells from all previous tasks in the kernel by going to the top menu and then selecting Kernel > Restart and Run All\n___", "_____no_output_____" ] ], [ [ "(x_train, y_train), (x_test, y_test) = mnist.load_data()\nx_train = x_train.astype('float')/255.\nx_test = x_test.astype('float')/255.\n\nx_train = np.reshape(x_train, (60000, 784))\nx_test = np.reshape(x_test, (10000, 784))", "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz\n11493376/11490434 [==============================] - 0s 0us/step\n" ] ], [ [ "## Adding Noise\n___\nNote: If you are starting the notebook from this task, you can run cells from all previous tasks in the kernel by going to the top menu and then selecting Kernel > Restart and Run All\n___", "_____no_output_____" ] ], [ [ "x_train_noisy = x_train + np.random.rand(60000, 784)*0.9\nx_test_noisy = x_test + np.random.rand(10000, 784)*0.9\nx_train_noisy = np.clip(x_train_noisy, 0., 1.)\nx_test_noisy = np.clip(x_test_noisy, 0., 1.)", "_____no_output_____" ], [ "def Plot(x, p, labels = False):\n plt.figure(figsize = (20, 2))\n for i in range(10):\n plt.subplot(1, 10, i + 1)\n plt.imshow(x[i].reshape(28,28), cmap = 'viridis')\n plt.xticks([])\n plt.yticks([])\n if labels:\n plt.xlabel(np.argmax(p[i]))\n plt.show()\n \nPlot(x_train, None)", "_____no_output_____" ], [ "Plot(x_train_noisy, None)", "_____no_output_____" ] ], [ [ "## Building and Training a Classifier\n___\nNote: If you are starting the notebook from this task, you can run cells from all previous tasks in the kernel by going to the top menu and then selecting Kernel > Restart and Run All\n___", "_____no_output_____" ] ], [ [ "classifier = Sequential([\n Dense(256, activation = 'relu', input_shape = (784,)),\n Dense(256, activation = 'relu'),\n Dense(256, activation = 'softmax')\n])\n\nclassifier.compile(optimizer = 'adam',\n loss = 'sparse_categorical_crossentropy',\n metrics = ['accuracy'])\n\nclassifier.fit(x_train, y_train, batch_size = 512, epochs = 3)", "Epoch 1/3\n118/118 [==============================] - 2s 21ms/step - loss: 0.7610 - accuracy: 0.8274\nEpoch 2/3\n118/118 [==============================] - 3s 22ms/step - loss: 0.2073 - accuracy: 0.9405\nEpoch 3/3\n118/118 [==============================] - 3s 22ms/step - loss: 0.1464 - accuracy: 0.9575\n" ], [ "loss, acc = classifier.evaluate(x_test, y_test)\n\nprint(acc)", "313/313 [==============================] - 1s 2ms/step - loss: 0.1415 - accuracy: 0.9594\n0.9593999981880188\n" ], [ "loss, acc = classifier.evaluate(x_test_noisy, y_test)\n\nprint(acc)", "313/313 [==============================] - 0s 1ms/step - loss: 11.9475 - accuracy: 0.1621\n0.16210000216960907\n" ] ], [ [ "## Building the Autoencoder\n___\nNote: If you are starting the notebook from this task, you can run cells from all previous tasks in the kernel by going to the top menu and then selecting Kernel > Restart and Run All\n___", "_____no_output_____" ] ], [ [ "input_image = Input(shape = (784,))\nencoded = Dense(64, activation = 'relu')(input_image)\ndecoded = Dense(784, activation = 'sigmoid')(encoded)\n\nautoencoder = Model(input_image, decoded)\nautoencoder.compile(loss = 'binary_crossentropy', optimizer = 'adam')", "_____no_output_____" ] ], [ [ "## Training the Autoencoder\n___\nNote: If you are starting the notebook from this task, you can run cells from all previous tasks in the kernel by going to the top menu and then selecting Kernel > Restart and Run All\n___", "_____no_output_____" ] ], [ [ "autoencoder.fit(\n x_train_noisy, \n x_train,\n epochs = 100,\n batch_size = 512,\n validation_split = 0.2,\n verbose = False,\n callbacks = [\n EarlyStopping(monitor = 'val_loss', patience = 5),\n LambdaCallback(on_epoch_end = lambda e,l: print('{:.3f}'.format(l['val_loss']), end = ' _ '))\n ]\n)\n\nprint(' _ ')\nprint('Training is complete!')", "0.261 _ 0.236 _ 0.204 _ 0.187 _ 0.176 _ 0.166 _ 0.158 _ 0.151 _ 0.146 _ 0.141 _ 0.138 _ 0.134 _ 0.132 _ 0.129 _ 0.127 _ 0.125 _ 0.123 _ 0.122 _ 0.121 _ 0.119 _ 0.118 _ 0.117 _ 0.117 _ 0.116 _ 0.115 _ 0.115 _ 0.114 _ 0.114 _ 0.113 _ 0.113 _ 0.113 _ 0.113 _ 0.112 _ 0.112 _ 0.112 _ 0.112 _ 0.112 _ 0.112 _ 0.112 _ 0.112 _ 0.112 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.111 _ 0.110 _ 0.110 _ 0.110 _ _ \nTraining is complete!\n" ] ], [ [ "## Denoised Images\n___\nNote: If you are starting the notebook from this task, you can run cells from all previous tasks in the kernel by going to the top menu and then selecting Kernel > Restart and Run All\n___", "_____no_output_____" ] ], [ [ "preds = autoencoder.predict(x_test_noisy)", "_____no_output_____" ], [ "Plot(x_test_noisy, None)", "_____no_output_____" ], [ "Plot(preds, None)", "_____no_output_____" ], [ "loss, acc = classifier.evaluate(preds, y_test)\nprint(acc)", "313/313 [==============================] - 0s 2ms/step - loss: 0.2170 - accuracy: 0.9334\n0.9333999752998352\n" ] ], [ [ "## Composite Model\n___\nNote: If you are starting the notebook from this task, you can run cells from all previous tasks in the kernel by going to the top menu and then selecting Kernel > Restart and Run All\n___", "_____no_output_____" ] ], [ [ "input_image=Input(shape=(784,))\nx=autoencoder(input_image)\ny=classifier(x)\n\ndenoise_and_classfiy = Model(input_image, y)", "_____no_output_____" ], [ "predictions=denoise_and_classfiy.predict(x_test_noisy)", "_____no_output_____" ], [ "Plot(x_test_noisy, predictions, True)", "_____no_output_____" ], [ "Plot(x_test, to_categorical(y_test), True)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Text Annotation Example", "_____no_output_____" ] ], [ [ "%pip install transformers==4.17.0 -qq\n!git clone https://github.com/AMontgomerie/bulgarian-nlp\n%cd bulgarian-nlp", "Cloning into 'bulgarian-nlp'...\nremote: Enumerating objects: 141, done.\u001b[K\nremote: Counting objects: 100% (141/141), done.\u001b[K\nremote: Compressing objects: 100% (126/126), done.\u001b[K\nremote: Total 141 (delta 62), reused 9 (delta 2), pack-reused 0\u001b[K\nReceiving objects: 100% (141/141), 70.39 KiB | 1.68 MiB/s, done.\nResolving deltas: 100% (62/62), done.\n/content/bulgarian-nlp\n" ] ], [ [ "First we create an instance of the annotator.", "_____no_output_____" ] ], [ [ "from annotation.annotators import TextAnnotator\n\nannotator = TextAnnotator()", "_____no_output_____" ] ], [ [ "Next we create an example input and pass it as an argument to the annotator.", "_____no_output_____" ] ], [ [ "example_input = 'България е член на ЕС.'\nannotations = annotator(example_input)\nannotations", "_____no_output_____" ] ], [ [ "As you can see, the raw output is a dictionary of tokens and corresponding tags. To make it more readable, let's display the tag level output as a dataframe.", "_____no_output_____" ] ], [ [ "import pandas as pd\n\ntokens = [t[\"text\"] for t in annotations[\"tokens\"]]\npos_tags = [t[\"pos\"] for t in annotations[\"tokens\"]]\nentity_tags = [t[\"entity\"] for t in annotations[\"tokens\"]]\ndf = pd.DataFrame({\"token\": tokens, \"pos\": pos_tags, \"entity\": entity_tags})\ndf", "_____no_output_____" ] ], [ [ "For more information about the meanings of the POS tags, see https://universaldependencies.org/u/pos/\n\n\nThe sentence level entities are also available in `annotations[\"entities\"]`:", "_____no_output_____" ] ], [ [ "for entity in annotations[\"entities\"]:\n print(f\"{entity['text']}: {entity['type']}\")", "България: LOCATION\nЕС: ORGANISATION\n" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Randomized experiments", "_____no_output_____" ], [ "* **Athey, S., & Imbens, G. (2017)**. [Chapter 3 - The econometrics of randomized experiments](https://www.sciencedirect.com/science/article/abs/pii/S2214658X16300174), in *Handbook of Economic Field Experiments*, 73-140.\n\n\n* **Freedman, D.A. (2008)**. [On regression adjustments to experimental data](https://www.sciencedirect.com/science/article/pii/S019688580700005X), *Advances in Applied Mathematics*, 40(2), 180-193.\n", "_____no_output_____" ] ] ]

[ "markdown" ]

[ [ "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Lab 04 : Train vanilla neural network -- solution\n\n\n# Training a one-layer net on FASHION-MNIST", "_____no_output_____" ] ], [ [ "# For Google Colaboratory\nimport sys, os\nif 'google.colab' in sys.modules:\n from google.colab import drive\n drive.mount('/content/gdrive')\n file_name = 'train_vanilla_nn_solution.ipynb'\n import subprocess\n path_to_file = subprocess.check_output('find . -type f -name ' + str(file_name), shell=True).decode(\"utf-8\")\n print(path_to_file)\n path_to_file = path_to_file.replace(file_name,\"\").replace('\\n',\"\")\n os.chdir(path_to_file)\n !pwd", "_____no_output_____" ], [ "import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nimport torch.optim as optim\nfrom random import randint\nimport utils", "_____no_output_____" ] ], [ [ "### Download the TRAINING SET (data+labels)", "_____no_output_____" ] ], [ [ "from utils import check_fashion_mnist_dataset_exists\ndata_path=check_fashion_mnist_dataset_exists()\n\ntrain_data=torch.load(data_path+'fashion-mnist/train_data.pt')\ntrain_label=torch.load(data_path+'fashion-mnist/train_label.pt')\nprint(train_data.size())\nprint(train_label.size())", "torch.Size([60000, 28, 28])\ntorch.Size([60000])\n" ] ], [ [ "### Download the TEST SET (data only)", "_____no_output_____" ] ], [ [ "test_data=torch.load(data_path+'fashion-mnist/test_data.pt')\nprint(test_data.size())", "torch.Size([10000, 28, 28])\n" ] ], [ [ "### Make a one layer net class", "_____no_output_____" ] ], [ [ "class one_layer_net(nn.Module):\n\n def __init__(self, input_size, output_size):\n super(one_layer_net , self).__init__()\n self.linear_layer = nn.Linear( input_size, output_size , bias=False)\n \n def forward(self, x):\n y = self.linear_layer(x)\n prob = F.softmax(y, dim=1)\n return prob", "_____no_output_____" ] ], [ [ "### Build the net", "_____no_output_____" ] ], [ [ "net=one_layer_net(784,10)\nprint(net)", "one_layer_net(\n (linear_layer): Linear(in_features=784, out_features=10, bias=False)\n)\n" ] ], [ [ "### Take the 4th image of the test set:", "_____no_output_____" ] ], [ [ "im=test_data[4]\nutils.show(im)", "_____no_output_____" ] ], [ [ "### And feed it to the UNTRAINED network:", "_____no_output_____" ] ], [ [ "p = net( im.view(1,784)) \nprint(p)", "tensor([[0.1320, 0.0970, 0.0802, 0.0831, 0.1544, 0.0777, 0.1040, 0.1219, 0.0820,\n 0.0678]], grad_fn=<SoftmaxBackward>)\n" ] ], [ [ "### Display visually the confidence scores", "_____no_output_____" ] ], [ [ "utils.show_prob_fashion_mnist(p)", "_____no_output_____" ] ], [ [ "### Train the network (only 5000 iterations) on the train set", "_____no_output_____" ] ], [ [ "criterion = nn.NLLLoss()\noptimizer=torch.optim.SGD(net.parameters() , lr=0.01 )\n\nfor iter in range(1,5000):\n \n # choose a random integer between 0 and 59,999 \n # extract the corresponding picture and label\n # and reshape them to fit the network\n idx=randint(0, 60000-1)\n input=train_data[idx].view(1,784)\n label=train_label[idx].view(1)\n\n\n # feed the input to the net \n input.requires_grad_()\n prob=net(input) \n \n # update the weights (all the magic happens here -- we will discuss it later)\n log_prob=torch.log(prob)\n loss = criterion(log_prob, label) \n optimizer.zero_grad() \n loss.backward()\n optimizer.step()", "_____no_output_____" ] ], [ [ "### Take the 34th image of the test set:", "_____no_output_____" ] ], [ [ "im=test_data[34]\nutils.show(im)", "_____no_output_____" ] ], [ [ "### Feed it to the TRAINED net:", "_____no_output_____" ] ], [ [ "p = net( im.view(1,784)) \nprint(p)", "tensor([[2.3781e-04, 8.4407e-06, 6.5949e-03, 6.4070e-03, 5.8398e-03, 3.5421e-02,\n 5.3267e-03, 5.8309e-04, 9.3951e-01, 6.6500e-05]],\n grad_fn=<SoftmaxBackward>)\n" ] ], [ [ "### Display visually the confidence scores", "_____no_output_____" ] ], [ [ "utils.show_prob_fashion_mnist(prob)", "_____no_output_____" ] ], [ [ "### Choose image at random from the test set and see how good/bad are the predictions", "_____no_output_____" ] ], [ [ "# choose a picture at random\nidx=randint(0, 10000-1)\nim=test_data[idx]\n\n# diplay the picture\nutils.show(im)\n\n# feed it to the net and display the confidence scores\nprob = net( im.view(1,784)) \nutils.show_prob_fashion_mnist(prob)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/TerradasExatas/IA_e_Machine_Learning/blob/main/IA_ConvNN_classificacao_MNIST.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ] ], [ [ "#https://machinelearningmastery.com/how-to-develop-a-convolutional-neural-network-from-scratch-for-mnist-handwritten-digit-classification/\n#https://towardsdatascience.com/convolutional-neural-networks-for-beginners-using-keras-and-tensorflow-2-c578f7b3bf25\n#https://github.com/jorditorresBCN/python-deep-learning/blob/master/08_redes_neuronales_convolucionales.ipynb", "_____no_output_____" ], [ "import tensorflow as tf\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n#importa o dataset (as imagens da base \"mnist\")\nmnist = tf.keras.datasets.mnist\n(train_images, train_labels), (test_images, test_labels) = mnist.load_data()\n\n#inspeciona o data set\nprint('train imagens original shape:',train_images.shape)\nprint('train labels original shape:',train_labels.shape)\n\nplt.rcParams.update({'font.size':14})\nplt.figure(figsize=(8,4))\nfor i in range(2*4):\n plt.subplot(2,4,i+1)\n plt.xticks([]);plt.yticks([])\n plt.imshow(train_images[i],cmap=plt.cm.binary)\n plt.xlabel(str(train_labels[i]))\nplt.show()\n\n#prepara o data set\ntrain_images = train_images.reshape((60000, 28, 28, 1))\ntrain_images = train_images.astype('float32') / 255\n\ntest_images = test_images.reshape((10000, 28, 28, 1))\ntest_images = test_images.astype('float32') / 255\n\n#inspeciona os dados preparados\nprint ('train images new shape:',train_images.shape)\n\nN_class=10\n#Criando a rede neural\nmodel = tf.keras.Sequential(name='rede_IF_CNN_MNIST')\n#Adicionando as camadas\nmodel.add(tf.keras.layers.Conv2D(12, (5, 5), \n activation='relu', input_shape=(28, 28, 1)))\nmodel.add(tf.keras.layers.MaxPooling2D((2, 2)))\nmodel.add(tf.keras.layers.Conv2D(24, (3, 3), activation='relu'))\nmodel.add(tf.keras.layers.MaxPooling2D((2, 2)))\nmodel.add(tf.keras.layers.Flatten())\nmodel.add(tf.keras.layers.Dense(N_class, activation='softmax'))\n\n#compilando a rede\nopt=tf.keras.optimizers.Adam(learning_rate=0.002)\nmodel.compile(optimizer=opt, loss='sparse_categorical_crossentropy',\n metrics=['accuracy'])\nmodel.summary()\n\n# treinando a rede\nhistory=model.fit(train_images, train_labels,epochs=8,verbose=1)\n\n#mostra a performace do treinamento da rede\nplt.figure()\nplt.subplot(2,1,1);plt.semilogy(history.history['loss'],'k')\nplt.legend(['loss'])\nplt.subplot(2,1,2);plt.plot(history.history['accuracy'],'k')\nplt.legend(['acuracia'])\nplt.tight_layout()\n\n#testando a rede com os dados de teste\npred = model.predict(test_images)\ntest_loss, test_acc = model.evaluate(test_images, test_labels, verbose=2)\nprint('\\n accuracia dos dados de teste: ', test_acc)\n\n#encontra a classe de maior probabilidade\nlabels_pred=np.argmax(pred,axis=1)\n#mostra 15 resultados esperados e os alcançados lado a lado\nprint('data and pred = \\n',np.concatenate(\n (test_labels[None].T[0:15], labels_pred[None].T[0:15]),axis=1))", "train imagens original shape: (60000, 28, 28)\ntrain labels original shape: (60000,)\n" ] ] ]

[ "markdown", "code" ]

[ [ "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "from pandas import read_csv\nimport cv2\nimport glob\nimport os\nimport numpy as np\nimport logging\nimport coloredlogs\nlogger = logging.getLogger(__name__)\ncoloredlogs.install(level='DEBUG')\ncoloredlogs.install(level='DEBUG', logger=logger)", "_____no_output_____" ], [ "IM_EXTENSIONS = ['png', 'jpg', 'jpeg', 'bmp']", "_____no_output_____" ], [ "def read_img(img_path, img_shape=(128, 128)):\n \"\"\"\n load image file and divide by 255.\n \"\"\"\n img = cv2.imread(img_path)\n img = cv2.resize(img, img_shape)\n img = img.astype('float')\n img /= 255.\n\n return img", "_____no_output_____" ], [ "dataset_dir = './data/images/'\nlabel_path = './data/label.csv'\nbatch_size=32,\nimg_shape=(128, 128)", "_____no_output_____" ], [ "label_df = read_csv(label_path)\n# img_files = glob.glob(dataset_dir + '*')\n# img_files = [f for f in img_files if f[-3:] in IM_EXTENSIONS]\n\nlabel_idx = label_df.set_index('filename')\nimg_files = label_idx.index.unique().values", "_____no_output_____" ], [ "label_idx.loc['0_Parade_Parade_0_628.jpg'].head()", "_____no_output_____" ], [ "label_idx.iloc[0:5]", "_____no_output_____" ], [ "len(img_files)", "_____no_output_____" ], [ "def append_zero(arr):\n return np.append([0], arr)", "_____no_output_____" ], [ "# temp = label_idx.loc[img_files[0]].values[:, :4] #[0, 26, 299, 36, 315]\n# np.apply_along_axis(append_zero, 1, temp)", "_____no_output_____" ], [ "\"\"\"\ndata loader\n\nreturn image, [class_label, class_and_location_label]\n\"\"\"\n\nnumofData = len(img_files) # endwiths(png,jpg ...)\ndata_idx = np.arange(numofData)\n\nwhile True:\n batch_idx = np.random.choice(data_idx, size=batch_size, replace=False)\n\n batch_img = []\n batch_label = []\n batch_label_cls = []\n\n for i in batch_idx:\n\n img = read_img(dataset_dir + img_files[i], img_shape=img_shape)\n label_idx = label_df.set_index('filename')\n img_files = label_idx.index.unique().values\n label = label_idx.loc[img_files[i]].values\n label = np.array(label, ndmin=2)\n label = label[:, :4]\n cls_loc_label = np.apply_along_axis(append_zero, 1, label)\n batch_img.append(img)\n batch_label.append(label)\n batch_label_cls.append(0) # label[0:1]) ---> face\n# yield ({'input_1': np.array(batch_img, dtype=np.float32)},\n# {'clf_output': np.array(batch_label_cls, dtype=np.float32),\n# 'bb_output': np.array(batch_label, dtype=np.float32)})\n", "[[0 244 104 306 191]\n [0 317 425 381 501]\n [0 490 313 558 406]\n [0 641 90 702 157]]\n" ], [ "import tensorflow as tf", "_____no_output_____" ], [ "def dataloader(dataset_dir, label_path, batch_size=1000, img_shape=(128, 128)):\n \"\"\"\n data loader\n\n return image, [class_label, class_and_location_label]\n \"\"\"\n\n label_df = read_csv(label_path)\n label_idx = label_df.set_index('filename')\n img_files = label_idx.index.unique().values\n\n numofData = len(img_files) # endwiths(png,jpg ...)\n data_idx = np.arange(numofData)\n\n while True:\n batch_idx = np.random.choice(data_idx, size=batch_size, replace=False)\n\n batch_img = []\n batch_label = []\n batch_class = []\n\n for i in batch_idx:\n\n img = read_img(dataset_dir + img_files[i], img_shape=img_shape)\n\n label = label_idx.loc[img_files[i]].values\n label = np.array(label, ndmin=2)\n label = label[:, :4]\n\n cls_loc_label = np.apply_along_axis(append_zero, 1, label)\n\n batch_img.append(img)\n batch_label.append(cls_loc_label) # face + bb\n batch_class.append(cls_loc_label[:, 0:1]) # label[:, 0:1]) ---> face\n\n# yield {'input_1': np.array(batch_img, dtype=np.float32)}, {'clf_output': np.array(batch_class, dtype=np.float32),'bb_output': np.array(batch_label, dtype=np.float32)}\n \n yield np.array(batch_img, dtype=np.float32), [np.array(batch_class, dtype=np.float32), np.array(batch_label, dtype=np.float32)]", "_____no_output_____" ], [ "data_gen = dataloader(dataset_dir, label_path, batch_size=1, img_shape=(128, 128))", "_____no_output_____" ], [ "data = next(data_gen)", "_____no_output_____" ], [ "len(data)", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "\n<font color = \"mediumblue\">Note: Notebook was updated July 2, 2019 with bug fixes.</font>\n\n#### If you were working on the older version:\n* Please click on the \"Coursera\" icon in the top right to open up the folder directory. \n* Navigate to the folder: Week 3/ Planar data classification with one hidden layer. You can see your prior work in version 5: Planar data classification with one hidden layer v5.ipynb\n\n#### List of bug fixes and enhancements\n* Clarifies that the classifier will learn to classify regions as either red or blue.\n* compute_cost function fixes np.squeeze by casting it as a float.\n* compute_cost instructions clarify the purpose of np.squeeze.\n* compute_cost clarifies that \"parameters\" parameter is not needed, but is kept in the function definition until the auto-grader is also updated.\n* nn_model removes extraction of parameter values, as the entire parameter dictionary is passed to the invoked functions.", "_____no_output_____" ], [ "# Planar data classification with one hidden layer\n\nWelcome to your week 3 programming assignment. It's time to build your first neural network, which will have a hidden layer. You will see a big difference between this model and the one you implemented using logistic regression. \n\n**You will learn how to:**\n- Implement a 2-class classification neural network with a single hidden layer\n- Use units with a non-linear activation function, such as tanh \n- Compute the cross entropy loss \n- Implement forward and backward propagation\n", "_____no_output_____" ], [ "## 1 - Packages ##\n\nLet's first import all the packages that you will need during this assignment.\n- [numpy](https://www.numpy.org/) is the fundamental package for scientific computing with Python.\n- [sklearn](http://scikit-learn.org/stable/) provides simple and efficient tools for data mining and data analysis. \n- [matplotlib](http://matplotlib.org) is a library for plotting graphs in Python.\n- testCases provides some test examples to assess the correctness of your functions\n- planar_utils provide various useful functions used in this assignment", "_____no_output_____" ] ], [ [ "# Package imports\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom testCases_v2 import *\nimport sklearn\nimport sklearn.datasets\nimport sklearn.linear_model\nfrom planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets\n\n%matplotlib inline\n\nnp.random.seed(1) # set a seed so that the results are consistent", "_____no_output_____" ] ], [ [ "## 2 - Dataset ##\n\nFirst, let's get the dataset you will work on. The following code will load a \"flower\" 2-class dataset into variables `X` and `Y`.", "_____no_output_____" ] ], [ [ "X, Y = load_planar_dataset()", "_____no_output_____" ] ], [ [ "Visualize the dataset using matplotlib. The data looks like a \"flower\" with some red (label y=0) and some blue (y=1) points. Your goal is to build a model to fit this data. In other words, we want the classifier to define regions as either red or blue.", "_____no_output_____" ] ], [ [ "# Visualize the data:\nplt.scatter(X[0, :], X[1, :], c=Y, s=40, cmap=plt.cm.Spectral);", "_____no_output_____" ] ], [ [ "You have:\n - a numpy-array (matrix) X that contains your features (x1, x2)\n - a numpy-array (vector) Y that contains your labels (red:0, blue:1).\n\nLets first get a better sense of what our data is like. \n\n**Exercise**: How many training examples do you have? In addition, what is the `shape` of the variables `X` and `Y`? \n\n**Hint**: How do you get the shape of a numpy array? [(help)](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.shape.html)", "_____no_output_____" ] ], [ [ "### START CODE HERE ### (≈ 3 lines of code)\nshape_X = None\nshape_Y = None\nm = X.shape[1] # training set size\n### END CODE HERE ###\n\nprint ('The shape of X is: ' + str(shape_X))\nprint ('The shape of Y is: ' + str(shape_Y))\nprint ('I have m = %d training examples!' % (m))", "The shape of X is: (2, 400)\nThe shape of Y is: (1, 400)\nI have m = 400 training examples!\n" ] ], [ [ "**Expected Output**:\n \n<table style=\"width:20%\">\n \n <tr>\n <td>**shape of X**</td>\n <td> (2, 400) </td> \n </tr>\n \n <tr>\n <td>**shape of Y**</td>\n <td>(1, 400) </td> \n </tr>\n \n <tr>\n <td>**m**</td>\n <td> 400 </td> \n </tr>\n \n</table>", "_____no_output_____" ], [ "## 3 - Simple Logistic Regression\n\nBefore building a full neural network, lets first see how logistic regression performs on this problem. You can use sklearn's built-in functions to do that. Run the code below to train a logistic regression classifier on the dataset.", "_____no_output_____" ] ], [ [ "# Train the logistic regression classifier\nclf = sklearn.linear_model.LogisticRegressionCV();\nclf.fit(X.T, Y.T);", "_____no_output_____" ] ], [ [ "You can now plot the decision boundary of these models. Run the code below.", "_____no_output_____" ] ], [ [ "# Plot the decision boundary for logistic regression\nplot_decision_boundary(lambda x: clf.predict(x), X, Y)\nplt.title(\"Logistic Regression\")\n\n# Print accuracy\nLR_predictions = clf.predict(X.T)\nprint ('Accuracy of logistic regression: %d ' % float((np.dot(Y,LR_predictions) + np.dot(1-Y,1-LR_predictions))/float(Y.size)*100) +\n '% ' + \"(percentage of correctly labelled datapoints)\")", "Accuracy of logistic regression: 47 % (percentage of correctly labelled datapoints)\n" ] ], [ [ "**Expected Output**:\n\n<table style=\"width:20%\">\n <tr>\n <td>**Accuracy**</td>\n <td> 47% </td> \n </tr>\n \n</table>\n", "_____no_output_____" ], [ "**Interpretation**: The dataset is not linearly separable, so logistic regression doesn't perform well. Hopefully a neural network will do better. Let's try this now! ", "_____no_output_____" ], [ "## 4 - Neural Network model\n\nLogistic regression did not work well on the \"flower dataset\". You are going to train a Neural Network with a single hidden layer.\n\n**Here is our model**:\n<img src=\"images/classification_kiank.png\" style=\"width:600px;height:300px;\">\n\n**Mathematically**:\n\nFor one example $x^{(i)}$:\n$$z^{[1] (i)} = W^{[1]} x^{(i)} + b^{[1]}\\tag{1}$$ \n$$a^{[1] (i)} = \\tanh(z^{[1] (i)})\\tag{2}$$\n$$z^{[2] (i)} = W^{[2]} a^{[1] (i)} + b^{[2]}\\tag{3}$$\n$$\\hat{y}^{(i)} = a^{[2] (i)} = \\sigma(z^{ [2] (i)})\\tag{4}$$\n$$y^{(i)}_{prediction} = \\begin{cases} 1 & \\mbox{if } a^{[2](i)} > 0.5 \\\\ 0 & \\mbox{otherwise } \\end{cases}\\tag{5}$$\n\nGiven the predictions on all the examples, you can also compute the cost $J$ as follows: \n$$J = - \\frac{1}{m} \\sum\\limits_{i = 0}^{m} \\large\\left(\\small y^{(i)}\\log\\left(a^{[2] (i)}\\right) + (1-y^{(i)})\\log\\left(1- a^{[2] (i)}\\right) \\large \\right) \\small \\tag{6}$$\n\n**Reminder**: The general methodology to build a Neural Network is to:\n 1. Define the neural network structure ( # of input units, # of hidden units, etc). \n 2. Initialize the model's parameters\n 3. Loop:\n - Implement forward propagation\n - Compute loss\n - Implement backward propagation to get the gradients\n - Update parameters (gradient descent)\n\nYou often build helper functions to compute steps 1-3 and then merge them into one function we call `nn_model()`. Once you've built `nn_model()` and learnt the right parameters, you can make predictions on new data.", "_____no_output_____" ], [ "### 4.1 - Defining the neural network structure ####\n\n**Exercise**: Define three variables:\n - n_x: the size of the input layer\n - n_h: the size of the hidden layer (set this to 4) \n - n_y: the size of the output layer\n\n**Hint**: Use shapes of X and Y to find n_x and n_y. Also, hard code the hidden layer size to be 4.", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: layer_sizes\n\ndef layer_sizes(X, Y):\n \"\"\"\n Arguments:\n X -- input dataset of shape (input size, number of examples)\n Y -- labels of shape (output size, number of examples)\n \n Returns:\n n_x -- the size of the input layer\n n_h -- the size of the hidden layer\n n_y -- the size of the output layer\n \"\"\"\n ### START CODE HERE ### (≈ 3 lines of code)\n n_x = None # size of input layer\n n_h = None\n n_y = None # size of output layer\n ### END CODE HERE ###\n return (n_x, n_h, n_y)", "_____no_output_____" ], [ "X_assess, Y_assess = layer_sizes_test_case()\n(n_x, n_h, n_y) = layer_sizes(X_assess, Y_assess)\nprint(\"The size of the input layer is: n_x = \" + str(n_x))\nprint(\"The size of the hidden layer is: n_h = \" + str(n_h))\nprint(\"The size of the output layer is: n_y = \" + str(n_y))", "The size of the input layer is: n_x = 5\nThe size of the hidden layer is: n_h = 4\nThe size of the output layer is: n_y = 2\n" ] ], [ [ "**Expected Output** (these are not the sizes you will use for your network, they are just used to assess the function you've just coded).\n\n<table style=\"width:20%\">\n <tr>\n <td>**n_x**</td>\n <td> 5 </td> \n </tr>\n \n <tr>\n <td>**n_h**</td>\n <td> 4 </td> \n </tr>\n \n <tr>\n <td>**n_y**</td>\n <td> 2 </td> \n </tr>\n \n</table>", "_____no_output_____" ], [ "### 4.2 - Initialize the model's parameters ####\n\n**Exercise**: Implement the function `initialize_parameters()`.\n\n**Instructions**:\n- Make sure your parameters' sizes are right. Refer to the neural network figure above if needed.\n- You will initialize the weights matrices with random values. \n - Use: `np.random.randn(a,b) * 0.01` to randomly initialize a matrix of shape (a,b).\n- You will initialize the bias vectors as zeros. \n - Use: `np.zeros((a,b))` to initialize a matrix of shape (a,b) with zeros.", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: initialize_parameters\n\ndef initialize_parameters(n_x, n_h, n_y):\n \"\"\"\n Argument:\n n_x -- size of the input layer\n n_h -- size of the hidden layer\n n_y -- size of the output layer\n \n Returns:\n params -- python dictionary containing your parameters:\n W1 -- weight matrix of shape (n_h, n_x)\n b1 -- bias vector of shape (n_h, 1)\n W2 -- weight matrix of shape (n_y, n_h)\n b2 -- bias vector of shape (n_y, 1)\n \"\"\"\n \n np.random.seed(2) # we set up a seed so that your output matches ours although the initialization is random.\n\n \n ### START CODE HERE ### (≈ 4 lines of code)\n W1 = None\n b1 = None\n W2 = None\n b2 = None\n ### END CODE HERE ###\n \n assert (W1.shape == (n_h, n_x))\n assert (b1.shape == (n_h, 1))\n assert (W2.shape == (n_y, n_h))\n assert (b2.shape == (n_y, 1))\n \n parameters = {\"W1\": W1,\n \"b1\": b1,\n \"W2\": W2,\n \"b2\": b2}\n \n return parameters", "_____no_output_____" ], [ "n_x, n_h, n_y = initialize_parameters_test_case()\n\nparameters = initialize_parameters(n_x, n_h, n_y)\nprint(\"W1 = \" + str(parameters[\"W1\"]))\nprint(\"b1 = \" + str(parameters[\"b1\"]))\nprint(\"W2 = \" + str(parameters[\"W2\"]))\nprint(\"b2 = \" + str(parameters[\"b2\"]))", "W1 = [[-0.00416758 -0.00056267]\n [-0.02136196 0.01640271]\n [-0.01793436 -0.00841747]\n [ 0.00502881 -0.01245288]]\nb1 = [[ 0.]\n [ 0.]\n [ 0.]\n [ 0.]]\nW2 = [[-0.01057952 -0.00909008 0.00551454 0.02292208]]\nb2 = [[ 0.]]\n" ] ], [ [ "**Expected Output**:\n\n<table style=\"width:90%\">\n <tr>\n <td>**W1**</td>\n <td> [[-0.00416758 -0.00056267]\n [-0.02136196 0.01640271]\n [-0.01793436 -0.00841747]\n [ 0.00502881 -0.01245288]] </td> \n </tr>\n \n <tr>\n <td>**b1**</td>\n <td> [[ 0.]\n [ 0.]\n [ 0.]\n [ 0.]] </td> \n </tr>\n \n <tr>\n <td>**W2**</td>\n <td> [[-0.01057952 -0.00909008 0.00551454 0.02292208]]</td> \n </tr>\n \n\n <tr>\n <td>**b2**</td>\n <td> [[ 0.]] </td> \n </tr>\n \n</table>\n\n", "_____no_output_____" ], [ "### 4.3 - The Loop ####\n\n**Question**: Implement `forward_propagation()`.\n\n**Instructions**:\n- Look above at the mathematical representation of your classifier.\n- You can use the function `sigmoid()`. It is built-in (imported) in the notebook.\n- You can use the function `np.tanh()`. It is part of the numpy library.\n- The steps you have to implement are:\n 1. Retrieve each parameter from the dictionary \"parameters\" (which is the output of `initialize_parameters()`) by using `parameters[\"..\"]`.\n 2. Implement Forward Propagation. Compute $Z^{[1]}, A^{[1]}, Z^{[2]}$ and $A^{[2]}$ (the vector of all your predictions on all the examples in the training set).\n- Values needed in the backpropagation are stored in \"`cache`\". The `cache` will be given as an input to the backpropagation function.", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: forward_propagation\n\ndef forward_propagation(X, parameters):\n \"\"\"\n Argument:\n X -- input data of size (n_x, m)\n parameters -- python dictionary containing your parameters (output of initialization function)\n \n Returns:\n A2 -- The sigmoid output of the second activation\n cache -- a dictionary containing \"Z1\", \"A1\", \"Z2\" and \"A2\"\n \"\"\"\n # Retrieve each parameter from the dictionary \"parameters\"\n ### START CODE HERE ### (≈ 4 lines of code)\n W1 = None\n b1 = None\n W2 = None\n b2 = None\n ### END CODE HERE ###\n \n # Implement Forward Propagation to calculate A2 (probabilities)\n ### START CODE HERE ### (≈ 4 lines of code)\n Z1 = None\n A1 = None\n Z2 = None\n A2 = None\n ### END CODE HERE ###\n \n assert(A2.shape == (1, X.shape[1]))\n \n cache = {\"Z1\": Z1,\n \"A1\": A1,\n \"Z2\": Z2,\n \"A2\": A2}\n \n return A2, cache", "_____no_output_____" ], [ "X_assess, parameters = forward_propagation_test_case()\nA2, cache = forward_propagation(X_assess, parameters)\n\n# Note: we use the mean here just to make sure that your output matches ours. \nprint(np.mean(cache['Z1']) ,np.mean(cache['A1']),np.mean(cache['Z2']),np.mean(cache['A2']))", "0.262818640198 0.091999045227 -1.30766601287 0.212877681719\n" ] ], [ [ "**Expected Output**:\n<table style=\"width:50%\">\n <tr>\n <td> 0.262818640198 0.091999045227 -1.30766601287 0.212877681719 </td> \n </tr>\n</table>", "_____no_output_____" ], [ "Now that you have computed $A^{[2]}$ (in the Python variable \"`A2`\"), which contains $a^{[2](i)}$ for every example, you can compute the cost function as follows:\n\n$$J = - \\frac{1}{m} \\sum\\limits_{i = 1}^{m} \\large{(} \\small y^{(i)}\\log\\left(a^{[2] (i)}\\right) + (1-y^{(i)})\\log\\left(1- a^{[2] (i)}\\right) \\large{)} \\small\\tag{13}$$\n\n**Exercise**: Implement `compute_cost()` to compute the value of the cost $J$.\n\n**Instructions**:\n- There are many ways to implement the cross-entropy loss. To help you, we give you how we would have implemented\n$- \\sum\\limits_{i=0}^{m} y^{(i)}\\log(a^{[2](i)})$:\n```python\nlogprobs = np.multiply(np.log(A2),Y)\ncost = - np.sum(logprobs) # no need to use a for loop!\n```\n\n(you can use either `np.multiply()` and then `np.sum()` or directly `np.dot()`). \nNote that if you use `np.multiply` followed by `np.sum` the end result will be a type `float`, whereas if you use `np.dot`, the result will be a 2D numpy array. We can use `np.squeeze()` to remove redundant dimensions (in the case of single float, this will be reduced to a zero-dimension array). We can cast the array as a type `float` using `float()`.", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: compute_cost\n\ndef compute_cost(A2, Y, parameters):\n \"\"\"\n Computes the cross-entropy cost given in equation (13)\n \n Arguments:\n A2 -- The sigmoid output of the second activation, of shape (1, number of examples)\n Y -- \"true\" labels vector of shape (1, number of examples)\n parameters -- python dictionary containing your parameters W1, b1, W2 and b2\n [Note that the parameters argument is not used in this function, \n but the auto-grader currently expects this parameter.\n Future version of this notebook will fix both the notebook \n and the auto-grader so that `parameters` is not needed.\n For now, please include `parameters` in the function signature,\n and also when invoking this function.]\n \n Returns:\n cost -- cross-entropy cost given equation (13)\n \n \"\"\"\n \n m = Y.shape[1] # number of example\n\n # Compute the cross-entropy cost\n ### START CODE HERE ### (≈ 2 lines of code)\n logprobs = None\n cost = None\n ### END CODE HERE ###\n \n cost = float(np.squeeze(cost)) # makes sure cost is the dimension we expect. \n # E.g., turns [[17]] into 17 \n assert(isinstance(cost, float))\n \n return cost", "_____no_output_____" ], [ "A2, Y_assess, parameters = compute_cost_test_case()\n\nprint(\"cost = \" + str(compute_cost(A2, Y_assess, parameters)))", "cost = 0.6930587610394646\n" ] ], [ [ "**Expected Output**:\n<table style=\"width:20%\">\n <tr>\n <td>**cost**</td>\n <td> 0.693058761... </td> \n </tr>\n \n</table>", "_____no_output_____" ], [ "Using the cache computed during forward propagation, you can now implement backward propagation.\n\n**Question**: Implement the function `backward_propagation()`.\n\n**Instructions**:\nBackpropagation is usually the hardest (most mathematical) part in deep learning. To help you, here again is the slide from the lecture on backpropagation. You'll want to use the six equations on the right of this slide, since you are building a vectorized implementation. \n\n<img src=\"images/grad_summary.png\" style=\"width:600px;height:300px;\">\n\n<!--\n$\\frac{\\partial \\mathcal{J} }{ \\partial z_{2}^{(i)} } = \\frac{1}{m} (a^{[2](i)} - y^{(i)})$\n\n$\\frac{\\partial \\mathcal{J} }{ \\partial W_2 } = \\frac{\\partial \\mathcal{J} }{ \\partial z_{2}^{(i)} } a^{[1] (i) T} $\n\n$\\frac{\\partial \\mathcal{J} }{ \\partial b_2 } = \\sum_i{\\frac{\\partial \\mathcal{J} }{ \\partial z_{2}^{(i)}}}$\n\n$\\frac{\\partial \\mathcal{J} }{ \\partial z_{1}^{(i)} } = W_2^T \\frac{\\partial \\mathcal{J} }{ \\partial z_{2}^{(i)} } * ( 1 - a^{[1] (i) 2}) $\n\n$\\frac{\\partial \\mathcal{J} }{ \\partial W_1 } = \\frac{\\partial \\mathcal{J} }{ \\partial z_{1}^{(i)} } X^T $\n\n$\\frac{\\partial \\mathcal{J} _i }{ \\partial b_1 } = \\sum_i{\\frac{\\partial \\mathcal{J} }{ \\partial z_{1}^{(i)}}}$\n\n- Note that $*$ denotes elementwise multiplication.\n- The notation you will use is common in deep learning coding:\n - dW1 = $\\frac{\\partial \\mathcal{J} }{ \\partial W_1 }$\n - db1 = $\\frac{\\partial \\mathcal{J} }{ \\partial b_1 }$\n - dW2 = $\\frac{\\partial \\mathcal{J} }{ \\partial W_2 }$\n - db2 = $\\frac{\\partial \\mathcal{J} }{ \\partial b_2 }$\n \n!-->\n\n- Tips:\n - To compute dZ1 you'll need to compute $g^{[1]'}(Z^{[1]})$. Since $g^{[1]}(.)$ is the tanh activation function, if $a = g^{[1]}(z)$ then $g^{[1]'}(z) = 1-a^2$. So you can compute \n $g^{[1]'}(Z^{[1]})$ using `(1 - np.power(A1, 2))`.", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: backward_propagation\n\ndef backward_propagation(parameters, cache, X, Y):\n \"\"\"\n Implement the backward propagation using the instructions above.\n \n Arguments:\n parameters -- python dictionary containing our parameters \n cache -- a dictionary containing \"Z1\", \"A1\", \"Z2\" and \"A2\".\n X -- input data of shape (2, number of examples)\n Y -- \"true\" labels vector of shape (1, number of examples)\n \n Returns:\n grads -- python dictionary containing your gradients with respect to different parameters\n \"\"\"\n m = X.shape[1]\n \n # First, retrieve W1 and W2 from the dictionary \"parameters\".\n ### START CODE HERE ### (≈ 2 lines of code)\n W1 = None\n W2 = None\n ### END CODE HERE ###\n \n # Retrieve also A1 and A2 from dictionary \"cache\".\n ### START CODE HERE ### (≈ 2 lines of code)\n A1 = None\n A2 = None\n ### END CODE HERE ###\n \n # Backward propagation: calculate dW1, db1, dW2, db2. \n ### START CODE HERE ### (≈ 6 lines of code, corresponding to 6 equations on slide above)\n dZ2 = None\n dW2 = None\n db2 = None\n dZ1 = None\n dW1 = None\n db1 = None\n ### END CODE HERE ###\n \n grads = {\"dW1\": dW1,\n \"db1\": db1,\n \"dW2\": dW2,\n \"db2\": db2}\n \n return grads", "_____no_output_____" ], [ "parameters, cache, X_assess, Y_assess = backward_propagation_test_case()\n\ngrads = backward_propagation(parameters, cache, X_assess, Y_assess)\nprint (\"dW1 = \"+ str(grads[\"dW1\"]))\nprint (\"db1 = \"+ str(grads[\"db1\"]))\nprint (\"dW2 = \"+ str(grads[\"dW2\"]))\nprint (\"db2 = \"+ str(grads[\"db2\"]))", "dW1 = [[ 0.00301023 -0.00747267]\n [ 0.00257968 -0.00641288]\n [-0.00156892 0.003893 ]\n [-0.00652037 0.01618243]]\ndb1 = [[ 0.00176201]\n [ 0.00150995]\n [-0.00091736]\n [-0.00381422]]\ndW2 = [[ 0.00078841 0.01765429 -0.00084166 -0.01022527]]\ndb2 = [[-0.16655712]]\n" ] ], [ [ "**Expected output**:\n\n\n\n<table style=\"width:80%\">\n <tr>\n <td>**dW1**</td>\n <td> [[ 0.00301023 -0.00747267]\n [ 0.00257968 -0.00641288]\n [-0.00156892 0.003893 ]\n [-0.00652037 0.01618243]] </td> \n </tr>\n \n <tr>\n <td>**db1**</td>\n <td> [[ 0.00176201]\n [ 0.00150995]\n [-0.00091736]\n [-0.00381422]] </td> \n </tr>\n \n <tr>\n <td>**dW2**</td>\n <td> [[ 0.00078841 0.01765429 -0.00084166 -0.01022527]] </td> \n </tr>\n \n\n <tr>\n <td>**db2**</td>\n <td> [[-0.16655712]] </td> \n </tr>\n \n</table> ", "_____no_output_____" ], [ "**Question**: Implement the update rule. Use gradient descent. You have to use (dW1, db1, dW2, db2) in order to update (W1, b1, W2, b2).\n\n**General gradient descent rule**: $ \\theta = \\theta - \\alpha \\frac{\\partial J }{ \\partial \\theta }$ where $\\alpha$ is the learning rate and $\\theta$ represents a parameter.\n\n**Illustration**: The gradient descent algorithm with a good learning rate (converging) and a bad learning rate (diverging). Images courtesy of Adam Harley.\n\n<img src=\"images/sgd.gif\" style=\"width:400;height:400;\"> <img src=\"images/sgd_bad.gif\" style=\"width:400;height:400;\">\n\n", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: update_parameters\n\ndef update_parameters(parameters, grads, learning_rate = 1.2):\n \"\"\"\n Updates parameters using the gradient descent update rule given above\n \n Arguments:\n parameters -- python dictionary containing your parameters \n grads -- python dictionary containing your gradients \n \n Returns:\n parameters -- python dictionary containing your updated parameters \n \"\"\"\n # Retrieve each parameter from the dictionary \"parameters\"\n ### START CODE HERE ### (≈ 4 lines of code)\n W1 = None\n b1 = None\n W2 = None\n b2 = None\n ### END CODE HERE ###\n \n # Retrieve each gradient from the dictionary \"grads\"\n ### START CODE HERE ### (≈ 4 lines of code)\n dW1 = None\n db1 = None\n dW2 = None\n db2 = None\n ## END CODE HERE ###\n \n # Update rule for each parameter\n ### START CODE HERE ### (≈ 4 lines of code)\n W1 = None\n b1 = None\n W2 = None\n b2 = None\n ### END CODE HERE ###\n \n parameters = {\"W1\": W1,\n \"b1\": b1,\n \"W2\": W2,\n \"b2\": b2}\n \n return parameters", "_____no_output_____" ], [ "parameters, grads = update_parameters_test_case()\nparameters = update_parameters(parameters, grads)\n\nprint(\"W1 = \" + str(parameters[\"W1\"]))\nprint(\"b1 = \" + str(parameters[\"b1\"]))\nprint(\"W2 = \" + str(parameters[\"W2\"]))\nprint(\"b2 = \" + str(parameters[\"b2\"]))", "W1 = [[-0.00643025 0.01936718]\n [-0.02410458 0.03978052]\n [-0.01653973 -0.02096177]\n [ 0.01046864 -0.05990141]]\nb1 = [[ 1.21732533e-05]\n [ 2.12263977e-05]\n [ 1.36755874e-05]\n [ 1.05251698e-05]]\nW2 = [[-0.01041081 -0.04463285 0.01758031 0.04747113]]\nb2 = [[ 0.00010457]]\n" ] ], [ [ "**Expected Output**:\n\n\n<table style=\"width:80%\">\n <tr>\n <td>**W1**</td>\n <td> [[-0.00643025 0.01936718]\n [-0.02410458 0.03978052]\n [-0.01653973 -0.02096177]\n [ 0.01046864 -0.05990141]]</td> \n </tr>\n \n <tr>\n <td>**b1**</td>\n <td> [[ -1.02420756e-06]\n [ 1.27373948e-05]\n [ 8.32996807e-07]\n [ -3.20136836e-06]]</td> \n </tr>\n \n <tr>\n <td>**W2**</td>\n <td> [[-0.01041081 -0.04463285 0.01758031 0.04747113]] </td> \n </tr>\n \n\n <tr>\n <td>**b2**</td>\n <td> [[ 0.00010457]] </td> \n </tr>\n \n</table> ", "_____no_output_____" ], [ "### 4.4 - Integrate parts 4.1, 4.2 and 4.3 in nn_model() ####\n\n**Question**: Build your neural network model in `nn_model()`.\n\n**Instructions**: The neural network model has to use the previous functions in the right order.", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: nn_model\n\ndef nn_model(X, Y, n_h, num_iterations = 10000, print_cost=False):\n \"\"\"\n Arguments:\n X -- dataset of shape (2, number of examples)\n Y -- labels of shape (1, number of examples)\n n_h -- size of the hidden layer\n num_iterations -- Number of iterations in gradient descent loop\n print_cost -- if True, print the cost every 1000 iterations\n \n Returns:\n parameters -- parameters learnt by the model. They can then be used to predict.\n \"\"\"\n \n np.random.seed(3)\n n_x = layer_sizes(X, Y)[0]\n n_y = layer_sizes(X, Y)[2]\n \n # Initialize parameters\n ### START CODE HERE ### (≈ 1 line of code)\n parameters = None\n ### END CODE HERE ###\n \n # Loop (gradient descent)\n\n for i in range(0, num_iterations):\n \n ### START CODE HERE ### (≈ 4 lines of code)\n # Forward propagation. Inputs: \"X, parameters\". Outputs: \"A2, cache\".\n A2, cache = None\n \n # Cost function. Inputs: \"A2, Y, parameters\". Outputs: \"cost\".\n cost = None\n \n # Backpropagation. Inputs: \"parameters, cache, X, Y\". Outputs: \"grads\".\n grads = None\n \n # Gradient descent parameter update. Inputs: \"parameters, grads\". Outputs: \"parameters\".\n parameters = None\n \n ### END CODE HERE ###\n \n # Print the cost every 1000 iterations\n if print_cost and i % 1000 == 0:\n print (\"Cost after iteration %i: %f\" %(i, cost))\n\n return parameters", "_____no_output_____" ], [ "X_assess, Y_assess = nn_model_test_case()\nparameters = nn_model(X_assess, Y_assess, 4, num_iterations=10000, print_cost=True)\nprint(\"W1 = \" + str(parameters[\"W1\"]))\nprint(\"b1 = \" + str(parameters[\"b1\"]))\nprint(\"W2 = \" + str(parameters[\"W2\"]))\nprint(\"b2 = \" + str(parameters[\"b2\"]))", "Cost after iteration 0: 0.692739\nCost after iteration 1000: 0.000218\nCost after iteration 2000: 0.000107\nCost after iteration 3000: 0.000071\nCost after iteration 4000: 0.000053\nCost after iteration 5000: 0.000042\nCost after iteration 6000: 0.000035\nCost after iteration 7000: 0.000030\nCost after iteration 8000: 0.000026\nCost after iteration 9000: 0.000023\nW1 = [[-0.65848169 1.21866811]\n [-0.76204273 1.39377573]\n [ 0.5792005 -1.10397703]\n [ 0.76773391 -1.41477129]]\nb1 = [[ 0.287592 ]\n [ 0.3511264 ]\n [-0.2431246 ]\n [-0.35772805]]\nW2 = [[-2.45566237 -3.27042274 2.00784958 3.36773273]]\nb2 = [[ 0.20459656]]\n" ] ], [ [ "**Expected Output**:\n\n<table style=\"width:90%\">\n\n<tr> \n <td> \n **cost after iteration 0**\n </td>\n <td> \n 0.692739\n </td>\n</tr>\n\n<tr> \n <td> \n <center> $\\vdots$ </center>\n </td>\n <td> \n <center> $\\vdots$ </center>\n </td>\n</tr>\n\n <tr>\n <td>**W1**</td>\n <td> [[-0.65848169 1.21866811]\n [-0.76204273 1.39377573]\n [ 0.5792005 -1.10397703]\n [ 0.76773391 -1.41477129]]</td> \n </tr>\n \n <tr>\n <td>**b1**</td>\n <td> [[ 0.287592 ]\n [ 0.3511264 ]\n [-0.2431246 ]\n [-0.35772805]] </td> \n </tr>\n \n <tr>\n <td>**W2**</td>\n <td> [[-2.45566237 -3.27042274 2.00784958 3.36773273]] </td> \n </tr>\n \n\n <tr>\n <td>**b2**</td>\n <td> [[ 0.20459656]] </td> \n </tr>\n \n</table> ", "_____no_output_____" ], [ "### 4.5 Predictions\n\n**Question**: Use your model to predict by building predict().\nUse forward propagation to predict results.\n\n**Reminder**: predictions = $y_{prediction} = \\mathbb 1 \\text{{activation > 0.5}} = \\begin{cases}\n 1 & \\text{if}\\ activation > 0.5 \\\\\n 0 & \\text{otherwise}\n \\end{cases}$ \n \nAs an example, if you would like to set the entries of a matrix X to 0 and 1 based on a threshold you would do: ```X_new = (X > threshold)```", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: predict\n\ndef predict(parameters, X):\n \"\"\"\n Using the learned parameters, predicts a class for each example in X\n \n Arguments:\n parameters -- python dictionary containing your parameters \n X -- input data of size (n_x, m)\n \n Returns\n predictions -- vector of predictions of our model (red: 0 / blue: 1)\n \"\"\"\n \n # Computes probabilities using forward propagation, and classifies to 0/1 using 0.5 as the threshold.\n ### START CODE HERE ### (≈ 2 lines of code)\n A2, cache = None\n predictions = None\n ### END CODE HERE ###\n \n return predictions", "_____no_output_____" ], [ "parameters, X_assess = predict_test_case()\n\npredictions = predict(parameters, X_assess)\nprint(\"predictions mean = \" + str(np.mean(predictions)))", "predictions mean = 0.666666666667\n" ] ], [ [ "**Expected Output**: \n\n\n<table style=\"width:40%\">\n <tr>\n <td>**predictions mean**</td>\n <td> 0.666666666667 </td> \n </tr>\n \n</table>", "_____no_output_____" ], [ "It is time to run the model and see how it performs on a planar dataset. Run the following code to test your model with a single hidden layer of $n_h$ hidden units.", "_____no_output_____" ] ], [ [ "# Build a model with a n_h-dimensional hidden layer\nparameters = nn_model(X, Y, n_h = 4, num_iterations = 10000, print_cost=True)\n\n# Plot the decision boundary\nplot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)\nplt.title(\"Decision Boundary for hidden layer size \" + str(4))", "Cost after iteration 0: 0.693048\nCost after iteration 1000: 0.288083\nCost after iteration 2000: 0.254385\nCost after iteration 3000: 0.233864\nCost after iteration 4000: 0.226792\nCost after iteration 5000: 0.222644\nCost after iteration 6000: 0.219731\nCost after iteration 7000: 0.217504\nCost after iteration 8000: 0.219471\nCost after iteration 9000: 0.218612\n" ] ], [ [ "**Expected Output**:\n\n<table style=\"width:40%\">\n <tr>\n <td>**Cost after iteration 9000**</td>\n <td> 0.218607 </td> \n </tr>\n \n</table>\n", "_____no_output_____" ] ], [ [ "# Print accuracy\npredictions = predict(parameters, X)\nprint ('Accuracy: %d' % float((np.dot(Y,predictions.T) + np.dot(1-Y,1-predictions.T))/float(Y.size)*100) + '%')", "Accuracy: 90%\n" ] ], [ [ "**Expected Output**: \n\n<table style=\"width:15%\">\n <tr>\n <td>**Accuracy**</td>\n <td> 90% </td> \n </tr>\n</table>", "_____no_output_____" ], [ "Accuracy is really high compared to Logistic Regression. The model has learnt the leaf patterns of the flower! Neural networks are able to learn even highly non-linear decision boundaries, unlike logistic regression. \n\nNow, let's try out several hidden layer sizes.", "_____no_output_____" ], [ "### 4.6 - Tuning hidden layer size (optional/ungraded exercise) ###\n\nRun the following code. It may take 1-2 minutes. You will observe different behaviors of the model for various hidden layer sizes.", "_____no_output_____" ] ], [ [ "# This may take about 2 minutes to run\n\nplt.figure(figsize=(16, 32))\nhidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50]\nfor i, n_h in enumerate(hidden_layer_sizes):\n plt.subplot(5, 2, i+1)\n plt.title('Hidden Layer of size %d' % n_h)\n parameters = nn_model(X, Y, n_h, num_iterations = 5000)\n plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y)\n predictions = predict(parameters, X)\n accuracy = float((np.dot(Y,predictions.T) + np.dot(1-Y,1-predictions.T))/float(Y.size)*100)\n print (\"Accuracy for {} hidden units: {} %\".format(n_h, accuracy))", "Accuracy for 1 hidden units: 67.5 %\nAccuracy for 2 hidden units: 67.25 %\nAccuracy for 3 hidden units: 90.75 %\nAccuracy for 4 hidden units: 90.5 %\nAccuracy for 5 hidden units: 91.25 %\nAccuracy for 20 hidden units: 90.0 %\nAccuracy for 50 hidden units: 90.25 %\n" ] ], [ [ "**Interpretation**:\n- The larger models (with more hidden units) are able to fit the training set better, until eventually the largest models overfit the data. \n- The best hidden layer size seems to be around n_h = 5. Indeed, a value around here seems to fits the data well without also incurring noticeable overfitting.\n- You will also learn later about regularization, which lets you use very large models (such as n_h = 50) without much overfitting. ", "_____no_output_____" ], [ "**Optional questions**:\n\n**Note**: Remember to submit the assignment by clicking the blue \"Submit Assignment\" button at the upper-right. \n\nSome optional/ungraded questions that you can explore if you wish: \n- What happens when you change the tanh activation for a sigmoid activation or a ReLU activation?\n- Play with the learning_rate. What happens?\n- What if we change the dataset? (See part 5 below!)", "_____no_output_____" ], [ "<font color='blue'>\n**You've learnt to:**\n- Build a complete neural network with a hidden layer\n- Make a good use of a non-linear unit\n- Implemented forward propagation and backpropagation, and trained a neural network\n- See the impact of varying the hidden layer size, including overfitting.", "_____no_output_____" ], [ "Nice work! ", "_____no_output_____" ], [ "## 5) Performance on other datasets", "_____no_output_____" ], [ "If you want, you can rerun the whole notebook (minus the dataset part) for each of the following datasets.", "_____no_output_____" ] ], [ [ "# Datasets\nnoisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure = load_extra_datasets()\n\ndatasets = {\"noisy_circles\": noisy_circles,\n \"noisy_moons\": noisy_moons,\n \"blobs\": blobs,\n \"gaussian_quantiles\": gaussian_quantiles}\n\n### START CODE HERE ### (choose your dataset)\ndataset = \"noisy_moons\"\n### END CODE HERE ###\n\nX, Y = datasets[dataset]\nX, Y = X.T, Y.reshape(1, Y.shape[0])\n\n# make blobs binary\nif dataset == \"blobs\":\n Y = Y%2\n\n# Visualize the data\nplt.scatter(X[0, :], X[1, :], c=Y, s=40, cmap=plt.cm.Spectral);", "_____no_output_____" ] ], [ [ "Congrats on finishing this Programming Assignment!\n\nReference:\n- http://scs.ryerson.ca/~aharley/neural-networks/\n- http://cs231n.github.io/neural-networks-case-study/", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ] ]

[ "ECL-2.0", "Apache-2.0" ]

[ "ECL-2.0", "Apache-2.0" ]

[ "ECL-2.0", "Apache-2.0" ]

[ [ [ "from ecmwfapi import ECMWFDataServer", "_____no_output_____" ], [ "target = \"fire.nc\"\nprint target", "fire.nc\n" ] ], [ [ "I get the data", "_____no_output_____" ] ], [ [ "server = ECMWFDataServer(url = \"https://api.ecmwf.int/v1\",\n key = \"XXXXXXXXXXXXXXXX\",\n email = \"[email protected]\") \n\nrequest = {\n \"dataset\": \"geff_reanalysis\",\n \"date\": \"2016-12-01/to/2016-12-31\",\n \"origin\": \"fwis\",\n \"param\": \"fwi\",\n \"step\": \"00\",\n \"time\": \"0000\",\n \"type\": \"an\",\n \"target\": target,\n }\n\n \nserver.retrieve(request)\n\nprint \"Data are downloaded\"", "2017-02-27 16:57:07 ECMWF API python library 1.4.1\n2017-02-27 16:57:07 ECMWF API at https://api.ecmwf.int/v1\n2017-02-27 16:57:07 Welcome Sylvie Lamy-Thepaut\n2017-02-27 16:57:07 In case of problems, please check https://software.ecmwf.int/wiki/display/WEBAPI/Troubleshooting or contact [email protected]\n2017-02-27 16:57:07 \n2017-02-27 16:57:07 Request submitted\n2017-02-27 16:57:07 Request id: 58b45a6374a7fbec2ebc983a\n2017-02-27 16:57:07 Request is queued\n2017-02-27 17:34:46 Request is active\nCalling '['tar', '-cf', '/data/data01/scratch/get-files-atls19-95e2cf679cd58ee9b4db4dd119a05a8d-8mhWsc.tar', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161201_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161202_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161203_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161204_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161205_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161206_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161207_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161208_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161209_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161210_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161211_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161212_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161213_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161214_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161215_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161216_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161217_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161218_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161219_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161220_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161221_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161222_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161223_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161224_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161225_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161226_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161227_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161228_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161229_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161230_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161231_0000_00.nc.gz']'\nProcess '['tar', '-cf', '/data/data01/scratch/get-files-atls19-95e2cf679cd58ee9b4db4dd119a05a8d-8mhWsc.tar', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161201_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161202_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161203_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161204_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161205_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161206_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161207_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161208_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161209_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161210_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161211_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161212_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161213_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161214_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161215_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161216_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161217_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161218_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161219_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161220_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161221_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161222_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161223_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161224_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161225_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161226_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161227_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161228_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161229_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161230_0000_00.nc.gz', '-C', '/data/data01/scratch', 'geff_reanalysis_an_fwis_fwi_20161231_0000_00.nc.gz']' finished\n2017-02-27 17:34:51 Request is complete\n2017-02-27 17:34:51 Transfering 1.5625 Mbytes into fire.nc\n2017-02-27 17:34:51 From http://stream.ecmwf.int/data/atls19/data/data01/scratch/get-files-atls19-95e2cf679cd58ee9b4db4dd119a05a8d-8mhWsc.tar\n2017-02-27 17:34:51 Transfer rate 4.77369 Mbytes/s\nData are downloaded\n" ], [ "import Magics.macro as magics\n#Setting the coordinates of the geographical area\nprojection = magics.mmap(subpage_map_projection = 'robinson',\n )\n\nnetcdf = magics.mnetcdf(netcdf_filename='geff_reanalysis_an_fwis_fwi_20161214_0000_00.nc', \n netcdf_value_variable = 'fwi')\n\ncontour = magics.mcont(\n contour_shade='on',\n contour_shade_method = 'area_fill',\n contour_shade_colour_direction = \"clockwise\",\n contour_shade_colour_method = \"calculate\",\n contour_shade_max_level_colour= \"red\",\n contour_shade_min_level_colour= \"blue\",\n legend=\"on\",\n contour='off',\n contour_min_level=10.\n)\n\ntitle = magics.mtext(text_lines=[\"<netcdf_info variable='fwi' attribute='title'/>\"])\nlegend = magics.mlegend( legend_display_type = \"continuous\")\n\nmagics.plot(projection, netcdf, contour, title, magics.mcoast(), legend)", "_____no_output_____" ] ] ]

[ "code", "markdown", "code" ]

[ [ "code", "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Import Libraries and Packages\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport re\nimport datetime\nimport nltk\nfrom sklearn.cluster import KMeans\nfrom sklearn.metrics import adjusted_rand_score\neng_stopwords = nltk.corpus.stopwords.words('english')\narticles=pd.read_csv(\"New_marked_news.csv\").drop('Unnamed: 0', axis = 1)\narticles.head()", "_____no_output_____" ], [ "# df_marker_1=pd.read_csv(\"markerPosi.csv\")\n# df_marker_2=pd.read_csv(\"markerNega.csv\")\n# frames=[df_marker_1,df_marker_2]\n# df_marker= pd.concat(frames, ignore_index=True)\n# df_marker.tail()", "_____no_output_____" ], [ "#df['marker']=np.zeros(len(df))\n#for i in range(len(df)-1):\n #if df['date'][i] in df_marker['Date']:\n# df['marker'][i]=1\n# else:\n# df['marker'][i]=0\n# df", "_____no_output_____" ] ], [ [ "__Standardize timestamps__", "_____no_output_____" ] ], [ [ "#temp = pd.DatetimeIndex(articles['timeStamp']) # Gather all datetime objects\n#articles['date'] = temp.date # Pull out the date from the datetime objects and assign to Date column\n#articles['time'] = temp.time # Pull out the time from the datetime objects and assign to Time column\nprint(len(articles))\narticles.tail(3)", "7101\n" ], [ "articles.contents[10]", "_____no_output_____" ] ], [ [ "__Preprocess text for NLP formulations__", "_____no_output_____" ] ], [ [ "articles.head()", "_____no_output_____" ], [ "#Clean the articles - Remove stopwords, remove punctuation, all lowercase\nimport re\nfor i in articles.index:\n text = articles.loc[i, 'contents']\n if pd.isnull(text):\n pass\n else:\n text = re.sub(r\"[^a-zA-Z]\", \" \", text)\n text = [word for word in text.split() if not word in eng_stopwords]\n text = (' '.join(text))\n text = text.lower()\n articles.loc[i, 'contents'] = text", "_____no_output_____" ] ], [ [ "__Combine cleaned articles with \"Markers\" from Time Series event detection__ ", "_____no_output_____" ] ], [ [ "df=articles\ndf.to_csv(\"1119_article_data_and_price_labeled_publisher.csv\")", "_____no_output_____" ] ], [ [ "___", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<a href=\"https://cognitiveclass.ai/\">\n <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/CCLog.png\" width=\"200\" align=\"center\">\n</a>", "_____no_output_____" ], [ "<h1>2D <code>Numpy</code> in Python</h1>", "_____no_output_____" ], [ "<p><strong>Welcome!</strong> This notebook will teach you about using <code>Numpy</code> in the Python Programming Language. By the end of this lab, you'll know what <code>Numpy</code> is and the <code>Numpy</code> operations.</p>", "_____no_output_____" ], [ "<h2>Table of Contents</h2>\n<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n <ul>\n <li><a href=\"create\">Create a 2D Numpy Array</a></li>\n <li><a href=\"access\">Accessing different elements of a Numpy Array</a></li>\n <li><a href=\"op\">Basic Operations</a></li>\n </ul>\n <p>\n Estimated time needed: <strong>20 min</strong>\n </p>\n</div>\n\n<hr>", "_____no_output_____" ], [ "<h2 id=\"create\">Create a 2D Numpy Array</h2>", "_____no_output_____" ] ], [ [ "# Import the libraries\n\nimport numpy as np \nimport matplotlib.pyplot as plt", "_____no_output_____" ] ], [ [ "Consider the list <code>a</code>, the list contains three nested lists **each of equal size**. ", "_____no_output_____" ] ], [ [ "# Create a list\n\na = [[11, 12, 13], [21, 22, 23], [31, 32, 33]]\na", "_____no_output_____" ] ], [ [ "We can cast the list to a Numpy Array as follow", "_____no_output_____" ] ], [ [ "# Convert list to Numpy Array\n# Every element is the same type\n\nA = np.array(a)\nA", "_____no_output_____" ] ], [ [ "We can use the attribute <code>ndim</code> to obtain the number of axes or dimensions referred to as the rank. ", "_____no_output_____" ] ], [ [ "# Show the numpy array dimensions\n\nA.ndim", "_____no_output_____" ] ], [ [ "Attribute <code>shape</code> returns a tuple corresponding to the size or number of each dimension.", "_____no_output_____" ] ], [ [ "# Show the numpy array shape\n\nA.shape", "_____no_output_____" ] ], [ [ "The total number of elements in the array is given by the attribute <code>size</code>.", "_____no_output_____" ] ], [ [ "# Show the numpy array size\n\nA.size", "_____no_output_____" ] ], [ [ "<hr>", "_____no_output_____" ], [ "<h2 id=\"access\">Accessing different elements of a Numpy Array</h2>", "_____no_output_____" ], [ "We can use rectangular brackets to access the different elements of the array. The correspondence between the rectangular brackets and the list and the rectangular representation is shown in the following figure for a 3x3 array: ", "_____no_output_____" ], [ "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoEg.png\" width=\"500\" />", "_____no_output_____" ], [ "We can access the 2nd-row 3rd column as shown in the following figure:", "_____no_output_____" ], [ "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoFT.png\" width=\"400\" />", "_____no_output_____" ], [ " We simply use the square brackets and the indices corresponding to the element we would like:", "_____no_output_____" ] ], [ [ "# Access the element on the second row and third column\n\nA[1, 2]", "_____no_output_____" ] ], [ [ " We can also use the following notation to obtain the elements: ", "_____no_output_____" ] ], [ [ "# Access the element on the second row and third column\n\nA[1][2]", "_____no_output_____" ] ], [ [ " Consider the elements shown in the following figure ", "_____no_output_____" ], [ "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoFF.png\" width=\"400\" />", "_____no_output_____" ], [ "We can access the element as follows ", "_____no_output_____" ] ], [ [ "# Access the element on the first row and first column\n\nA[0][0]", "_____no_output_____" ] ], [ [ "We can also use slicing in numpy arrays. Consider the following figure. We would like to obtain the first two columns in the first row", "_____no_output_____" ], [ "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoFSF.png\" width=\"400\" />", "_____no_output_____" ], [ " This can be done with the following syntax ", "_____no_output_____" ] ], [ [ "# Access the element on the first row and first and second columns\n\nA[0][0:2]", "_____no_output_____" ] ], [ [ "Similarly, we can obtain the first two rows of the 3rd column as follows:", "_____no_output_____" ] ], [ [ "# Access the element on the first and second rows and third column\n\nA[0:2, 2]", "_____no_output_____" ] ], [ [ "Corresponding to the following figure: ", "_____no_output_____" ], [ "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoTST.png\" width=\"400\" />", "_____no_output_____" ], [ "<hr>", "_____no_output_____" ], [ "<h2 id=\"op\">Basic Operations</h2>", "_____no_output_____" ], [ "We can also add arrays. The process is identical to matrix addition. Matrix addition of <code>X</code> and <code>Y</code> is shown in the following figure:", "_____no_output_____" ], [ "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoAdd.png\" width=\"500\" />", "_____no_output_____" ], [ "The numpy array is given by <code>X</code> and <code>Y</code>", "_____no_output_____" ] ], [ [ "# Create a numpy array X\n\nX = np.array([[1, 0], [0, 1]]) \nX", "_____no_output_____" ], [ "# Create a numpy array Y\n\nY = np.array([[2, 1], [1, 2]]) \nY", "_____no_output_____" ] ], [ [ " We can add the numpy arrays as follows.", "_____no_output_____" ] ], [ [ "# Add X and Y\n\nZ = X + Y\nZ", "_____no_output_____" ] ], [ [ "Multiplying a numpy array by a scaler is identical to multiplying a matrix by a scaler. If we multiply the matrix <code>Y</code> by the scaler 2, we simply multiply every element in the matrix by 2 as shown in the figure.", "_____no_output_____" ], [ "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoDb.png\" width=\"500\" />", "_____no_output_____" ], [ "We can perform the same operation in numpy as follows ", "_____no_output_____" ] ], [ [ "# Create a numpy array Y\n\nY = np.array([[2, 1], [1, 2]]) \nY", "_____no_output_____" ], [ "# Multiply Y with 2\n\nZ = 2 * Y\nZ", "_____no_output_____" ] ], [ [ "Multiplication of two arrays corresponds to an element-wise product or Hadamard product. Consider matrix <code>X</code> and <code>Y</code>. The Hadamard product corresponds to multiplying each of the elements in the same position, i.e. multiplying elements contained in the same color boxes together. The result is a new matrix that is the same size as matrix <code>Y</code> or <code>X</code>, as shown in the following figure.", "_____no_output_____" ], [ "<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%205/Images/NumTwoMul.png\" width=\"500\" />", "_____no_output_____" ], [ "We can perform element-wise product of the array <code>X</code> and <code>Y</code> as follows:", "_____no_output_____" ] ], [ [ "# Create a numpy array Y\n\nY = np.array([[2, 1], [1, 2]]) \nY", "_____no_output_____" ], [ "# Create a numpy array X\n\nX = np.array([[1, 0], [0, 1]]) \nX", "_____no_output_____" ], [ "# Multiply X with Y\n\nZ = X * Y\nZ", "_____no_output_____" ] ], [ [ "We can also perform matrix multiplication with the numpy arrays <code>A</code> and <code>B</code> as follows:", "_____no_output_____" ], [ "First, we define matrix <code>A</code> and <code>B</code>:", "_____no_output_____" ] ], [ [ "# Create a matrix A\n\nA = np.array([[0, 1, 1], [1, 0, 1]])\nA", "_____no_output_____" ], [ "# Create a matrix B\n\nB = np.array([[1, 1], [1, 1], [-1, 1]])\nB", "_____no_output_____" ] ], [ [ "We use the numpy function <code>dot</code> to multiply the arrays together.", "_____no_output_____" ] ], [ [ "# Calculate the dot product\n\nZ = np.dot(A,B)\nZ", "_____no_output_____" ], [ "# Calculate the sine of Z\n\nnp.sin(Z)", "_____no_output_____" ] ], [ [ "We use the numpy attribute <code>T</code> to calculate the transposed matrix", "_____no_output_____" ] ], [ [ "# Create a matrix C\n\nC = np.array([[1,1],[2,2],[3,3]])\nC", "_____no_output_____" ], [ "# Get the transposed of C\n\nC.T", "_____no_output_____" ] ], [ [ "<hr>\n<h2>The last exercise!</h2>\n<p>Congratulations, you have completed your first lesson and hands-on lab in Python. However, there is one more thing you need to do. The Data Science community encourages sharing work. The best way to share and showcase your work is to share it on GitHub. By sharing your notebook on GitHub you are not only building your reputation with fellow data scientists, but you can also show it off when applying for a job. Even though this was your first piece of work, it is never too early to start building good habits. So, please read and follow <a href=\"https://cognitiveclass.ai/blog/data-scientists-stand-out-by-sharing-your-notebooks/\" target=\"_blank\">this article</a> to learn how to share your work.\n<hr>", "_____no_output_____" ], [ "<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n<h2>Get IBM Watson Studio free of charge!</h2>\n <p><a href=\"https://cocl.us/bottemNotebooksPython101Coursera\"><img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/BottomAd.png\" width=\"750\" align=\"center\"></a></p>\n</div>", "_____no_output_____" ], [ "<h3>About the Authors:</h3> \n<p><a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\" target=\"_blank\">Joseph Santarcangelo</a> is a Data Scientist at IBM, and holds a PhD in Electrical Engineering. His research focused on using Machine Learning, Signal Processing, and Computer Vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD.</p>", "_____no_output_____" ], [ "Other contributors: <a href=\"www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a>", "_____no_output_____" ], [ "<hr>", "_____no_output_____" ], [ "<p>Copyright &copy; 2018 IBM Developer Skills Network. This notebook and its source code are released under the terms of the <a href=\"https://cognitiveclass.ai/mit-license/\">MIT License</a>.</p>", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import scipy.special as sps\nimport pyro \nimport pyro.distributions as dist\nimport torch\nfrom torch.distributions import constraints\nfrom pyro.infer import MCMC, NUTS\nfrom scipy.stats import norm\nfrom torch import nn\nfrom pyro.infer.autoguide import AutoDiagonalNormal\nfrom pyro.nn import PyroModule\nfrom pyro import optim\nfrom pyro.infer import SVI, Trace_ELBO\nfrom pyro.nn import PyroSample\nfrom pyro.infer import Predictive\n\n\npyro.enable_validation(True)\npyro.set_rng_seed(1)\npyro.enable_validation(True)\n\nimport os\n\nimport pandas as pd \nimport numpy as np\nfrom matplotlib import pyplot as plt\nfrom mpl_toolkits.mplot3d import Axes3D\n\nimport statsmodels.api as sm\nimport statsmodels\n\n#import HNSCC_analysis_pipeline_lib as lib\n\nimport pickle as pkl\nimport seaborn as sbn\n\nprint(pyro.__version__)\nassert pyro.__version__.startswith('1.1.0')\n\nimport time\n\nfrom __future__ import print_function\nfrom ipywidgets import interact, interactive, fixed, interact_manual\nimport ipywidgets as widgets\n\nfrom scipy.stats import norm, gamma, poisson, beta \n\n%matplotlib inline", "1.1.0\n" ] ], [ [ "# Hill-Langmuir Bayesian Regression \n\nGoals similar to: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3773943/pdf/nihms187302.pdf \n\nHowever, they use a different paramerization that does not include Emax \n\n# Bayesian Hill Model Regression \n\nThe Hill model is defined as: \n\n$$ F(c, E_{max}, E_0, EC_{50}, H) = E_0 + \\frac{E_{max} - E_0}{1 + (\\frac{EC_{50}}{C})^H} $$\n\nWhere concentration, $c$ is in uM, and is *not* in logspace. \n\nTo quantify uncertainty in downstream modeling, and to allow placement of priors on the relevant variables, we will do this in a bayesian framework. \n\n# Building Intuition with the Hill Equation\n\n\n\n1. Di Veroli GY, Fornari C, Goldlust I, Mills G, Koh SB, Bramhall JL, et al. An automated fitting procedure and software for dose-response curves with multiphasic features. Scientific Reports. 2015 Oct 1;5(1):1–11. \n", "_____no_output_____" ] ], [ [ "# https://ipywidgets.readthedocs.io/en/latest/examples/Using%20Interact.html\ndef f(E0=2.5, Emax=0, log_EC50=-2, H=1):\n \n EC50 = 10**log_EC50\n plt.figure(2, figsize=(10,5))\n xx = np.logspace(-4, 1, 100)\n yy = E0 + (Emax - E0)/(1+(EC50/xx)**H)\n \n plt.plot(np.log10(xx),yy, 'r-')\n plt.ylim(-0.2, 3)\n plt.xlabel('log10 [Concentration (uM)] ')\n plt.ylabel('cell response')\n plt.show()\n\ninteractive_plot = interactive(f, E0=(0,3,0.5), Emax=(0.,1.,0.05), log_EC50=(-5,2,0.1), H=(1,5,1))\noutput = interactive_plot.children[-1]\noutput.layout.height = '350px'\ninteractive_plot", "_____no_output_____" ] ], [ [ "# Define Model + Guide ", "_____no_output_____" ] ], [ [ "class plotter: \n def __init__(self, params, figsize=(20,10), subplots = (2,7)): \n '''\n '''\n assert len(params) <= subplots[0]*subplots[1], 'wrong number of subplots for given params to report'\n self.fig, self.axes = plt.subplots(*subplots,figsize=figsize, sharex='col', sharey='row')\n self.vals = {p:[] for p in params}\n self.params = params\n \n def record(self):\n '''\n '''\n for p in self.params: \n self.vals[p].append(pyro.param(p).item())\n \n def plot_all(self): \n '''\n '''\n for p, ax in zip(self.params, self.axes.flat): \n ax.plot(self.vals[p], 'b-')\n ax.set_title(p, fontsize=25)\n ax.set_xlabel('step', fontsize=20)\n ax.set_ylabel('param value', fontsize=20)\n \n plt.subplots_adjust(left=None, bottom=None, right=None, top=None, wspace=None, hspace=0.35)\n plt.show()\n \ndef model(X, Y=None):\n '''\n \n '''\n E0 = pyro.sample('E0', dist.Normal(1., E0_std))\n\n Emax = pyro.sample('Emax', dist.Beta(a_emax, b_emax))\n \n H = pyro.sample('H', dist.Gamma(alpha_H, beta_H))\n \n EC50 = 10**pyro.sample('log_EC50', dist.Normal(mu_ec50, std_ec50))\n\n obs_sigma = pyro.sample(\"obs_sigma\", dist.Gamma(a_obs, b_obs))\n \n obs_mean = E0 + (Emax - E0)/(1+(EC50/X)**H)\n\n with pyro.plate(\"data\", X.shape[0]):\n obs = pyro.sample(\"obs\", dist.Normal(obs_mean.squeeze(-1), obs_sigma), obs=Y)\n \n return obs_mean\n\ndef guide(X, Y=None):\n \n _E0_mean = pyro.param('E0_mean', torch.tensor(0.))\n _E0_std = pyro.param('E0_std', torch.tensor(E0_std), constraint=constraints.positive)\n E0 = pyro.sample('E0', dist.Normal(_E0_mean, _E0_std))\n \n _a_emax = pyro.param('_a_emax', torch.tensor(a_emax), constraint=constraints.positive)\n _b_emax = pyro.param('_b_emax', torch.tensor(b_emax), constraint=constraints.positive)\n Emax = pyro.sample('Emax', dist.Beta(_a_emax, _b_emax))\n \n _alpha_H = pyro.param('_alpha_H', torch.tensor(alpha_H), constraint=constraints.positive)\n _beta_H = pyro.param('_beta_H', torch.tensor(beta_H), constraint=constraints.positive)\n H = pyro.sample('H', dist.Gamma(_alpha_H, _beta_H))\n\n _mu_ec50 = pyro.param('_mu_ec50', torch.tensor(mu_ec50))\n _std_ec50 = pyro.param('_std_ec50', torch.tensor(std_ec50), constraint=constraints.positive)\n EC50 = pyro.sample('log_EC50', dist.Normal(_mu_ec50, _std_ec50))\n \n _a_obs = pyro.param('_a_obs', torch.tensor(a_obs), constraint=constraints.positive)\n _b_obs = pyro.param('_b_obs', torch.tensor(b_obs), constraint=constraints.positive)\n obs_sigma = pyro.sample(\"obs_sigma\", dist.Gamma(_a_obs, _b_obs))\n \n obs_mean = E0 + (Emax - E0)/(1+(EC50/X)**H)\n \n return obs_mean", "_____no_output_____" ] ], [ [ "## choosing priors \n\n\n\n### $E_0$\nThe upper bound or maximum value of our function, $E_0$ should be centered at 1, although it's possible to be a little above or below that, we'll model this with a Normal distribution and a fairly tight variance around 1. \n\n$$ E_0 \\propto N(1, \\sigma_{E_0}) $$ \n\n### $E_{max}$ \n$E_{max}$ is the lower bound, or minimum value of our function, and is expected to be at 0, however, for some inhibitors it's significantly above this. \n\n$$ E_{max} \\propto Beta(a_{E_{max}}, b_{E_{max}}) $$ \n\n$$ e[E_{max}] = \\frac{a}{a+b} $$\n\n### H \n\nHill coefficient, $H$ should be a positive integer, however, we're going to approximate this as gamma since a poisson is not flexible enough to characterize this properly. \n\n$$ H \\propto gamma(\\alpha_{H}, \\beta_{H}) $$\n\n$$ Mean = E[gamma] = \\frac{ \\alpha_{H} }{\\beta_{H}} $$ \n\n### $EC_{50}$ \n\nEC50 was actually a little tough, we could imagine encoding IC50 as a gamma distribution in concentration space, however, this results in poor behavior when used in logspace. Therefore, it actually works much better to encode this as a Normal distribution in logspace. \n\n$$ log10(EC50) \\propto Normal(\\mu_{EC50}, \\sigma_{EC50}) $$ \n\n### cell viability ($Y$) \n\nWe'll assume this is a normal distribution, centered around the hill function with standard deviation $\\sigma_{obs}$. \n\n$$ \\mu_{obs} = E_0 + \\frac{E_{max} - E_0}{1 + (\\frac{EC_{50}}{C})^H} $$\n\n$$ Y \\propto N(\\mu_{obs}, \\sigma_{obs}) $$ ", "_____no_output_____" ], [ "# Building Prior Intuition \n\n## E0 Prior ", "_____no_output_____" ] ], [ [ "def f(E0_std):\n plt.figure(2)\n xx = np.linspace(-2, 4, 50)\n \n rv = norm(1, E0_std)\n yy = rv.pdf(xx)\n \n plt.ylim(0,1)\n plt.title('E0 parameter')\n plt.xlabel('E0')\n plt.ylabel('probability')\n plt.plot(xx, yy, 'r-')\n plt.show()\n\ninteractive_plot = interactive(f, E0_std=(0.1,4,0.1))\noutput = interactive_plot.children[-1]\noutput.layout.height = '350px'\ninteractive_plot", "_____no_output_____" ] ], [ [ "## Expecation, Variance to Alpha,Beta for Gamma ", "_____no_output_____" ] ], [ [ "def gamma_modes_to_params(E, S): \n '''\n '''\n beta = E/S \n alpha = E**2/S \n \n return alpha, beta\n ", "_____no_output_____" ] ], [ [ "## Emax Prior ", "_____no_output_____" ] ], [ [ "# TODO: Have inputs be E[] and Var[] rather than a,b... more useful for setting up priors. \ndef f(emax_mean=1, emax_var=3):\n \n a_emax, b_emax = gamma_modes_to_params(emax_mean, emax_var)\n \n plt.figure(2)\n xx = np.linspace(0, 1.2, 100)\n \n rv = gamma(a_emax, scale=1/b_emax, loc=0)\n yy = rv.pdf(xx)\n \n plt.title('Emax Parameter')\n plt.xlabel('Emax')\n plt.ylabel('probability')\n \n plt.ylim(0,5)\n plt.plot(xx, yy, 'r-', label=f'alpha={a_emax:.2f}, beta={b_emax:.2f}')\n plt.legend()\n plt.show()\n\ninteractive_plot = interactive(f, emax_mean=(0.1,1.2,0.05), emax_var=(0.01,1,0.05))\noutput = interactive_plot.children[-1]\noutput.layout.height = '350px'\ninteractive_plot", "_____no_output_____" ], [ "def f(alpha_H=1, beta_H=0.5):\n f, axes = plt.subplots(1,1,figsize=(5,5))\n \n xx = np.linspace(0, 5, 100)\n g = gamma(alpha_H, scale=1/beta_H, loc=0)\n yy = g.pdf(xx)\n \n axes.set_xlabel('H')\n axes.set_ylabel('probability')\n \n plt.xlim(0,5)\n plt.ylim(0,5)\n \n axes.plot(xx,yy, 'r-')\n plt.tight_layout()\n plt.title('Hill Coefficient')\n plt.show()\n\ninteractive_plot = interactive(f, alpha_H=(1,10,1), beta_H=(0.1,5,0.1))\noutput = interactive_plot.children[-1]\noutput.layout.height = '350px'\ninteractive_plot", "_____no_output_____" ], [ "def f(mu_ec50=-1, std_ec50=0.5):\n f, axes = plt.subplots(1,1,figsize=(5,5))\n \n xx = np.log10( np.logspace(-5, 2, 100) )\n g = norm(mu_ec50, std_ec50)\n yy = g.pdf(xx)\n \n axes.plot(xx,yy, 'r-')\n plt.xlabel('log10 EC50')\n plt.ylabel('probability')\n plt.title('EC50 parameter')\n plt.tight_layout()\n plt.show()\n\ninteractive_plot = interactive(f, mu_ec50=(-5,2,0.1), std_ec50=(0.01,5,0.1))\noutput = interactive_plot.children[-1]\noutput.layout.height = '350px'\ninteractive_plot", "_____no_output_____" ], [ "def f(a_obs=1, b_obs=1):\n plt.figure(2)\n xx = np.linspace(0, 3, 50)\n \n rv = gamma(a_obs, scale=1/b_obs, loc=0)\n yy = rv.pdf(xx)\n \n plt.ylim(0,5)\n plt.plot(xx, yy, 'r-')\n plt.xlabel('std_obs')\n plt.ylabel('probability')\n plt.title('Observation (Y) std')\n plt.show()\n\ninteractive_plot = interactive(f, a_obs=(1,100,1), b_obs=(1,100,1))\noutput = interactive_plot.children[-1]\noutput.layout.height = '350px'\ninteractive_plot", "_____no_output_____" ] ], [ [ "# Define Priors ", "_____no_output_____" ] ], [ [ "############ PRIORS ###############\nE0_std = 0.05\n\n# uniform\n# 50,100 -> example if we have strong support for Emax around 0.5 \na_emax = 50. #2.\nb_emax = 100. #8.\n\n# H gamma prior \nalpha_H = 1\nbeta_H = 1 \n\n#EC50\n# this is in logspace, so in uM -> 10**mu_ec50\nmu_ec50 = -2.\nstd_ec50 = 3.\n\n# obs error \na_obs = 1\nb_obs = 1\n###################################", "_____no_output_____" ] ], [ [ "# Define Data\n\nWe'll use fake data for now. ", "_____no_output_____" ] ], [ [ "Y = torch.tensor([1., 1., 1., 0.9, 0.7, 0.6, 0.5], dtype=torch.float)\nX = torch.tensor([10./3**i for i in range(7)][::-1], dtype=torch.float).unsqueeze(-1)", "_____no_output_____" ] ], [ [ "# Fit model with MCMC\n\nhttps://forum.pyro.ai/t/need-help-with-very-simple-model/600\nhttps://pyro.ai/examples/bayesian_regression_ii.html", "_____no_output_____" ] ], [ [ "torch.manual_seed(99999)\nnuts_kernel = NUTS(model, adapt_step_size=True)\nmcmc_run = MCMC(nuts_kernel, num_samples=400, warmup_steps=100, num_chains=1)\nmcmc_run.run(X,Y)", "Sample: 100%|██████████| 500/500 [00:32, 15.43it/s, step size=2.56e-01, acc. prob=0.949]\n" ] ], [ [ "## visualize results", "_____no_output_____" ] ], [ [ "samples = {k: v.detach().cpu().numpy() for k, v in mcmc_run.get_samples().items()}\n\nf, axes = plt.subplots(3,2, figsize=(10,5))\n\nfor ax, key in zip(axes.flat, samples.keys()): \n \n ax.set_title(key)\n ax.hist(samples[key], bins=np.linspace(min(samples[key]), max(samples[key]), 50), density=True)\n ax.set_xlabel(key)\n ax.set_ylabel('probability')\n \naxes.flat[-1].hist(10**samples['log_EC50'], bins=np.linspace(min(10**(samples['log_EC50'])), max(10**(samples['log_EC50'])), 50))\naxes.flat[-1].set_title('EC50')\naxes.flat[-1].set_xlabel('EC50 [uM]')\n \nplt.tight_layout()\nplt.show()", "_____no_output_____" ] ], [ [ "## plot fitted hill f-n", "_____no_output_____" ] ], [ [ "plt.figure(figsize=(7,7))\n\nxx = np.logspace(-7, 6, 200)\n\nfor i,s in pd.DataFrame(samples).iterrows(): \n yy = s.E0 + (s.Emax - s.E0)/(1+(10**s.log_EC50/xx)**s.H)\n plt.plot(np.log10(xx), yy, 'ro', alpha=0.01)\n \n \nplt.plot(np.log10(X), Y, 'b.', label='data')\nplt.xlabel('log10 Concentration')\nplt.ylabel('cell_viability')\nplt.ylim(0,1.2)\nplt.legend()\nplt.title('MCMC results')\nplt.show()", "_____no_output_____" ] ], [ [ "# Deprecated\n\n## EC50 example - gamma in concentration space ", "_____no_output_____" ] ], [ [ "def f(alpha_ec50=1, beta_ec50=0.5):\n f, axes = plt.subplots(1,2,figsize=(8,4))\n \n xx = np.logspace(-5, 2, 100)\n g = gamma(alpha_ec50, scale=1/beta_ec50, loc=0)\n yy = g.pdf(xx)\n \n g_samples = g.rvs(1000)\n \n axes[0].plot(xx,yy, 'r-')\n \n axes[1].plot(np.log10(xx), yy, 'b-')\n plt.tight_layout()\n plt.show()\n\ninteractive_plot = interactive(f, alpha_ec50=(1,10,1), beta_ec50=(0.01,5,0.1))\noutput = interactive_plot.children[-1]\noutput.layout.height = '350px'\ninteractive_plot", "_____no_output_____" ] ], [ [ "# Fit Model with `stochastic variational inference` ", "_____no_output_____" ] ], [ [ "adam = optim.Adam({\"lr\": 1e-1})\n\nsvi = SVI(model, guide, adam, loss=Trace_ELBO())\n\ntic = time.time()\nSTEPS = 2500\npyro.clear_param_store() \nmyplotter = plotter(['_alpha_H', '_beta_H', '_a_emax', '_b_emax', '_a_obs', '_b_obs', '_mu_ec50', '_std_ec50'], figsize=(12, 8), subplots=(2,5))\n_losses = []\nlast=0\nloss = 0\nn = 100\n\ntry: \n for j in range(STEPS):\n loss += svi.step(X, Y) \n myplotter.record()\n if j % n == 0:\n print(f\"[iteration {j}] loss: {(loss / n) :.2f} [change={(loss/n - last/n):.2f}]\", end='\\t\\t\\t\\r')\n _losses.append(np.log10(loss))\n last = loss\n loss = 0\n myplotter.plot_all()\nexcept: \n myplotter.plot_all()\n raise\n \nplt.figure()\nplt.plot(_losses)\nplt.xlabel('steps')\nplt.ylabel('loss')\nplt.show()\n\ntoc = time.time()\nprint(f'time to train {STEPS} iterations: {toc-tic:.2g}s')", "_____no_output_____" ], [ "x_data = torch.tensor(np.logspace(-5, 5, 200)).unsqueeze(-1)\n\ndef summary(samples):\n site_stats = {}\n for k, v in samples.items():\n site_stats[k] = {\n \"mean\": torch.mean(v, 0),\n \"std\": torch.std(v, 0),\n \"5%\": v.kthvalue(int(len(v) * 0.05), dim=0)[0],\n \"95%\": v.kthvalue(int(len(v) * 0.95), dim=0)[0],\n }\n return site_stats\n\n\npredictive = Predictive(model, guide=guide, num_samples=800,\n return_sites=(\"linear.weight\", \"obs\", \"_RETURN\"))\n\nsamples = predictive(x_data)\npred_summary = summary(samples)\n\ny_mean = pred_summary['obs']['mean'].detach().numpy()\ny_5 = pred_summary['obs']['5%'].detach().numpy()\ny_95 = pred_summary['obs']['95%'].detach().numpy()\n\nplt.figure(figsize=(7,7))\nplt.plot(np.log10(X),Y, 'k*', label='data')\nplt.plot(np.log10(x_data), y_mean, 'r-')\nplt.plot(np.log10(x_data), y_5, 'g-', label='95% Posterior Predictive CI')\nplt.plot(np.log10(x_data), y_95, 'g-')\n\nplt.ylim(0,1.2)\n\nplt.legend()\nplt.show()\n", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "ライブラリのインポートとバージョン表示", "_____no_output_____" ] ], [ [ "import pandas as pd\nimport numpy as np", "_____no_output_____" ], [ "import cesiumpy\ncesiumpy.__version__", "_____no_output_____" ] ], [ [ "CSVファイルの読み込み", "_____no_output_____" ] ], [ [ "filename = '07hoikuennyoutien-asakashi_utf8.csv'\ndf = pd.read_csv( filename )", "_____no_output_____" ] ], [ [ "バブルチャートの表示", "_____no_output_____" ] ], [ [ "v = cesiumpy.Viewer()\nfor i, row in df.iterrows():\n l = row['施設_収容人数［総定員］人数']\n p = cesiumpy.Point(position=[row['施設_経度'], row['施設_緯度'], 0] \n , pixelSize=l/5, color='blue')\n v.entities.add(p)\nv", "_____no_output_____" ] ], [ [ "3D棒グラフの表示", "_____no_output_____" ] ], [ [ "v = cesiumpy.Viewer()\nfor i, row in df.iterrows():\n l = row['施設_収容人数［総定員］人数']\n cyl = cesiumpy.Cylinder(position=[row['施設_経度'], row['施設_緯度'] ], \n length=l*10,topRadius=50, bottomRadius=50, material='aqua')\n v.entities.add(cyl)\nv", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/Asha-ai/BERT_abstractive_proj/blob/master/Untitled2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ] ], [ [ "", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

[ [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import pdfkit\nfrom string import Template\nimport numpy as np\n\nfrom PyPDF2 import PdfFileReader, PdfFileMerger\nimport glob", "_____no_output_____" ], [ "temp_address = r'C:\\Users\\Ol\\Documents\\EXPERIMENTS\\ACT_ID\\Materials\\projectsListTemp_pl.html'", "_____no_output_____" ], [ "# Import content\nwith open(r'C:\\Users\\Ol\\Documents\\EXPERIMENTS\\ACT_ID\\Materials\\progs_.txt', 'r', encoding='utf-8') as f:\n content = f.readlines()", "_____no_output_____" ], [ "# Strip newline characters\ncontent = [x.strip('\\n') for x in content]", "_____no_output_____" ], [ "header = \"\"\"&emsp;&emsp;Poniżej znajdziesz 10 krótkich opisów projektów naukowych \ni edukacyjnych, które będą dostępne dla studentów Florida Atlantic University i Uniwersytetu \nWarszawskiego w ramach międzynarodowego projektu \nrealizowanego przy współpracy Instytutu Studiów Społecznych UW (ISS UW) oraz \nDepartament of Psychology at Florida Atlantic University.\n<br><br>\nChcemy Cię prosić o ich ocenę. Uporządkuj je według Twoich \npreferencji.\n<br><br>\n<b>1</b> oznacza, że przyznajesz pierwsze miejsce, <b>10</b>, że ostatnie. \n<br><br>\nUdział w którym projekcie byłby dla Ciebie najbardziej atrakcyjny? <br><br>\n\"\"\"", "_____no_output_____" ], [ "def fill_temp(template_location, content):\n \n with open(template_location) as f:\n template = f.read()\n \n template = Template(template[6:])\n\n filled = template.safe_substitute(HEADER = header,\n DESCR = 'Skrócony opis projektu',\n POS = 'Pozycja',\n P1 = content[choice[0]],\n P2 = content[choice[1]],\n P3 = content[choice[2]],\n P4 = content[choice[3]],\n P5 = content[choice[4]],\n P6 = content[choice[5]],\n P7 = content[choice[6]],\n P8 = content[choice[7]],\n P9 = content[choice[8]],\n P10 = content[choice[9]])\n \n return filled\n ", "_____no_output_____" ], [ "# Define options\noptions = {'page-size': 'A4',\n 'encoding': \"utf-8\"}", "_____no_output_____" ], [ "# Generate pdfs\nfor i in range(50):\n choice = np.random.choice(10, 10, replace=False)\n quest_ready = fill_temp(temp_address, content)\n pdfkit.from_string(quest_ready, r'C:\\Users\\Ol\\Documents\\EXPERIMENTS\\ACT_ID\\Materials\\Pdf\\pList{:02}.pdf'.format(50+i), options=options)", "Loading pages (1/6)\nQNetworkAccessFileBackendFactory: URL has no schema set, use file:// for files\nCounting pages (2/6) \nResolving links (4/6) \nLoading headers and footers (5/6) \nPrinting pages (6/6)\nDone \nLoading pages (1/6)\nQNetworkAccessFileBackendFactory: URL has no schema set, use file:// for files\nCounting pages (2/6) \nResolving links (4/6) \nLoading headers and footers (5/6) \nPrinting pages (6/6)\nDone \nLoading pages (1/6)\nQNetworkAccessFileBackendFactory: URL has no schema set, use file:// for files\nCounting pages (2/6) \nResolving links (4/6) \nLoading headers and footers (5/6) \nPrinting pages (6/6)\nDone \nLoading pages (1/6)\nQNetworkAccessFileBackendFactory: URL has no schema set, use file:// for files\nCounting pages (2/6) \nResolving links (4/6) \nLoading headers and footers (5/6) \nPrinting pages (6/6)\nDone \nLoading pages (1/6)\nQNetworkAccessFileBackendFactory: URL has no schema set, use file:// for files\nCounting pages (2/6) \nResolving links (4/6) \nLoading headers and footers (5/6) \nPrinting pages (6/6)\nDone \nLoading pages (1/6)\nQNetworkAccessFileBackendFactory: URL has no schema set, use file:// for files\nCounting pages (2/6) \nResolving links (4/6) \nLoading headers and footers (5/6) \nPrinting pages (6/6)\nDone \nLoading pages (1/6)\nQNetworkAccessFileBackendFactory: URL has no schema set, use file:// for files\nCounting pages (2/6) \nResolving links (4/6) \nLoading headers and footers (5/6) \nPrinting pages (6/6)\nDone \nLoading pages (1/6)\nQNetworkAccessFileBackendFactory: URL has no schema set, use file:// for files\nCounting pages (2/6) \nResolving links (4/6) \nLoading headers and footers (5/6) \nPrinting pages (6/6)\nDone \nLoading pages (1/6)\nQNetworkAccessFileBackendFactory: URL has no schema set, use file:// for files\nCounting pages (2/6) \nResolving links (4/6) \nLoading headers and footers (5/6) \nPrinting pages (6/6)\nDone \nLoading pages (1/6)\nQNetworkAccessFileBackendFactory: URL has no schema set, use file:// for files\nCounting pages (2/6) \nResolving links (4/6) \nLoading headers and footers (5/6) \nPrinting pages (6/6)\nDone \n" ] ], [ [ "## Merge files\n\ninto one printable pdf", "_____no_output_____" ] ], [ [ "# Define naming pattern\npattern = r'C:\\Users\\Ol\\Documents\\EXPERIMENTS\\ACT_ID\\Materials\\PDF\\2\\*.pdf'", "_____no_output_____" ], [ "# Generate files list\npdfs_list = glob.glob(pattern)", "_____no_output_____" ], [ "# Merge and write the output file\n\nmerger = PdfFileMerger()\n\nfor f in pdfs_list:\n merger.append(PdfFileReader(f), 'rb')\n\nmerger.write(r'C:\\Users\\Ol\\Documents\\EXPERIMENTS\\ACT_ID\\Materials\\PDF\\FAU_UW_project2.pdf')", "_____no_output_____" ] ] ]

[ "code", "markdown", "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import os\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\nfrom PIL import Image", "_____no_output_____" ], [ "!echo \"loss,accuracy,val_loss,val_accuracy\" > curve.csv\n!cat ../face96_300eps.log | \\\ngrep -P \"\\s*1109/1109\" | \\\nsed -n \"s/^.*loss: \\([0-9\\.]*\\).*accuracy: \\([0-9\\.]*\\).*val_loss: \\([0-9\\.]*\\).*val_accuracy: \\([0-9\\.]*\\)$/\\1, \\2, \\3, \\4/p\" \\\n>> curve.csv", "_____no_output_____" ], [ "df = pd.read_csv('curve.csv')\ndf.head(5)", "_____no_output_____" ], [ "plt.plot(df['loss'], label=\"training loss\")\nplt.plot(df['val_loss'], label=\"validation loss\")\nplt.legend()\nplt.show()", "_____no_output_____" ], [ "fig = plt.figure()\nax = fig.add_subplot(1, 1, 1)\n\n# plot\nax.plot(df['accuracy'], label=\"training accuracy\")\nax.plot(df['val_accuracy'], label=\"validation accuracy\")\nax.set_xlabel('epoch')\nax.set_title('96x96 Grayscale Facial Sentiment Analysis Training Curve')\nax.legend()\n\n# save as png\nplt.savefig('figure.png')", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "%matplotlib inline", "_____no_output_____" ] ], [ [ "\n\n# About Dipoles in MEG and EEG\n\nFor an explanation of what is going on in the demo and background information\nabout magentoencephalography (MEG) and electroencephalography (EEG) in\ngeneral, let's walk through some code. To execute this code, you'll need\nto have a working version of python with ``mne`` installed, see the\n`quick-start` documentation for instructions. You'll need the development\nversion, so you'll need to do\n``pip install git+https://github.com/mne-tools/mne-python.git`` You'll also\nneed to install the requirements such as with\n``pip install -r requirements.txt``.\n", "_____no_output_____" ] ], [ [ "# Author: Alex Rockhill <[email protected]>\n#\n# License: BSD-3-Clause", "_____no_output_____" ] ], [ [ "Let's start by importing the dependencies we'll need.\n\n", "_____no_output_____" ] ], [ [ "import os.path as op # comes with python and helps naviagte to files\nimport numpy as np # a scientific computing package with arrays\nimport matplotlib.pyplot as plt # a plotting library\nimport mne # our main analysis software package\nfrom nilearn.plotting import plot_anat # this package plots brains", "_____no_output_____" ] ], [ [ "## Background\nMEG and EEG researchers record very small electromagentic potentials\ngenerated by the brain from outside the head. When it comes from the\nrecording devices, it looks like this (there are a lot of channels\nso only a subset are shown):\n\n", "_____no_output_____" ] ], [ [ "data_path = mne.datasets.sample.data_path() # get the sample data path\nraw = mne.io.read_raw( # navigate to some raw sample data\n op.join(data_path, 'MEG', 'sample', 'sample_audvis_raw.fif'))\nraw_plot = raw.copy() # make a copy to modify for plotting\nraw_plot.pick_channels(raw.ch_names[::10]) # pick only every tenth channel\nraw_plot.plot(n_channels=len(raw_plot.ch_names),\n duration=1, # only a small, 1 second time window\n start=50, # start part way in\n )", "_____no_output_____" ] ], [ [ "The goal of MEG and EEG researchers is to try and understand how activity\nin the brain changes as we respond to stimuli in our environment and\nperform behaviors. To do that, researchers will often use magnetic resonance\n(MR) to create an image of the research subject's brain. These images\nlook like this:\n\n", "_____no_output_____" ] ], [ [ "# first, get a T1-weighted MR scan file from the MNE example dataset\nT1_fname = op.join(data_path, 'subjects', 'sample', 'mri', 'T1.mgz')\nplot_anat(T1_fname) # now we can plot it", "_____no_output_____" ] ], [ [ "The T1 MR image can be used to figure out where the surfaces of the\nbrain skull and scalp are as well as label the parts of the brain\nin the image using Freesurfer. The command below does this (it takes\n8 hours so I wouldn't recommend executing it now but it has already\nbeen done for you in the mne sample data, see `here\n<https://surfer.nmr.mgh.harvard.edu/fswiki/DownloadAndInstall>`_ for\nhow to install Freesurfer):\n\n.. code-block:: bash\n\n recon-all -subjid sample -sd $DATA_PATH/subjects -i $T1_FNAME -all\n\n", "_____no_output_____" ], [ "Now let's put it all together and see the problem that MEG and EEG\nresearchers face in figuring out what's going on inside the brain from\nelectromagnetic potentials on the surface of the scalp. As you can see below,\nthere are a lot of MEG and EEG sensors and they cover a large portion of the\nhead but its not readily apparent how much of each brain area each sensor\nrecords from and how to separate the summed activity from all the brain areas\nthat is recorded by each sensor into components for each brain area:\n\n<div class=\"alert alert-info\"><h4>Note</h4><p>The sensor positions don't come aligned to the MR image since they are\n recorded by a different device so we need to a transformation matrix to\n transform them from the coordinate frame they are in to MR coordinates.\n This can be done with :func:`mne.gui.coregistration` to generate the\n ``trans`` file that is loaded below.</p></div>\n\n", "_____no_output_____" ] ], [ [ "# the subjects_dir is where Freesurfer stored all the surface files\nsubjects_dir = op.join(data_path, 'subjects')\ntrans = mne.read_trans(op.join(data_path, 'MEG', 'sample',\n 'sample_audvis_raw-trans.fif'))\n\n# the main plotter for mne, the brain object\nbrain = mne.viz.Brain(subject_id='sample', hemi='both', surf='pial',\n subjects_dir=subjects_dir)\nbrain.add_skull(alpha=0.5) # alpha sets transparency\nbrain.add_head(alpha=0.5)\nbrain.add_sensors(raw.info, trans)\n# set a nice view to show\nbrain.show_view(azimuth=120, elevation=90, distance=500)", "_____no_output_____" ] ], [ [ "## Making a Source Space and Forward Model\nFirst let's setup a space of vertices within the brain that we will consider\nas the sources of signal. In a real brain, there are hundreds of billions\nof cells but we don't have the resolution with only hundreds of sensors to\ndetermine the activity of each cell, so, instead, we'll choose a regularly\nsampled grid of sources that represent the summed activity of tens of\nthousands of cells. In most analyses in publications, the source space has\naround 8000 vertices, but, for this example, we'll use a smaller source\nspace for demonstration.\n\n", "_____no_output_____" ], [ "First, we would need to make a boundary element model (BEM) to account for\ndifferences in conductivity of the brain, skull and scalp. This can be\ndone with :func:`mne.make_bem_model` but, in this case, we'll just load\na pre-computed model. We'll also load the solution to the BEM model for how\ndifferent conductivities of issues effect current dipoles as they pass\nthrough each of the layers, but this can be computed with\n:func:`mne.make_bem_solution`.\n\n", "_____no_output_____" ] ], [ [ "bem_fname = op.join(subjects_dir, 'sample', 'bem',\n 'sample-5120-5120-5120-bem.fif')\n\n# load a pre-computed solution the how the sources within the brain will\n# be affected by the different conductivities\nbem_sol = op.join(subjects_dir, 'sample', 'bem',\n 'sample-5120-5120-5120-bem-sol.fif')\n# plot it, it's saved out in a standard location,\n# so we don't have to pass the path\nmne.viz.plot_bem(subject='sample', subjects_dir=op.join(data_path, 'subjects'),\n slices=np.linspace(45, 200, 12).round().astype(int))", "_____no_output_____" ] ], [ [ "## Making a Dipole\nNow, we're ready to make a dipole and see how its current will be recorded\nat the scalp with MEG and EEG.\n\n<div class=\"alert alert-info\"><h4>Note</h4><p>You can use ``print(mne.Dipole.__doc__)`` to print the arguments that\n are required by ``mne.Dipole`` or any other class, method or function.</p></div>\n\n", "_____no_output_____" ] ], [ [ "# make a dipole within the temporal lobe pointing superiorly,\n# fake a goodness-of-fit number\ndip_pos = [-0.0647572, 0.01315963, 0.07091921]\ndip = mne.Dipole(times=[0], pos=[dip_pos], amplitude=[3e-8],\n ori=[[0, 0, 1]], gof=50)\n\n# plot it!\nbrain = mne.viz.Brain(subject_id='sample', hemi='both', surf='pial',\n subjects_dir=subjects_dir, alpha=0.25)\nbrain.add_dipole(dip, trans, scales=10)\nbrain.show_view(azimuth=150, elevation=60, distance=500)", "_____no_output_____" ] ], [ [ "## Simulating Sensor Data\nWe're ready to compute a forward operator using the BEM to make the so-called\nleadfield matrix which multiplies activity at the dipole to give the\nmodelled the activity at the sensors. We can then use this to simulate evoked\ndata.\n\n", "_____no_output_____" ] ], [ [ "fwd, stc = mne.make_forward_dipole(\n dipole=dip, bem=bem_sol, info=raw.info, trans=trans)\n# we don't have a few things like the covarience matrix or a number of epochs\n# to average so we use these arguments for a reasonable solution\nevoked = mne.simulation.simulate_evoked(\n fwd, stc, raw.info, cov=None, nave=np.inf)\n\n# Now we can see what it would look like at the sensors\nfig, axes = plt.subplots(1, 3, figsize=(6, 4)) # make a figure with 3 subplots\n# use zip to iterate over axes and channel types at the same time\nfor ax, ch_type in zip(axes, ('grad', 'mag', 'eeg')):\n # we're just looking at the relative pattern so we won't use a colorbar\n evoked.plot_topomap(times=[0], ch_type=ch_type, axes=ax, colorbar=False)\n ax.set_title(ch_type)", "_____no_output_____" ] ], [ [ "## Wrapping Up\nWe covered some good intuition but there's lots more to learn! The main thing\nis that MEG and EEG researchers generally don't have the information about\nwhat's going on inside the brain, that's what they are trying to predict. To\nreverse this process, you need to invert the forward solution (tutorial:\n`tut-viz-stcs`). There is tons more to explore in the MNE `tutorials\n<https://mne.tools/dev/auto_tutorials/index.html>`_ and `examples\n<https://mne.tools/dev/auto_examples/index.html>`_ pages. Let's leave off by\nsetting up a source space of many different dipoles and seeing their\ndifferent activities manifest on the scalp as measured by the sensors.\n\n", "_____no_output_____" ] ], [ [ "src = mne.setup_volume_source_space(\n subject='sample', pos=20, # in mm\n bem=bem_fname, subjects_dir=subjects_dir)\n\n# make the leadfield matrix\nfwd = mne.make_forward_solution(\n raw.info, trans=trans, src=src, bem=bem_sol)\n\n# plot our setup\nbrain = mne.viz.Brain(subject_id='sample', hemi='both', surf='pial',\n subjects_dir=subjects_dir, alpha=0.25)\nbrain.add_volume_labels(alpha=0.25, colors='gray')\nbrain.add_forward(fwd, trans, scale=3)\nbrain.show_view(azimuth=30, elevation=90, distance=500)", "_____no_output_____" ] ], [ [ "Plot the same solution using a source space of dipoles\n\n", "_____no_output_____" ] ], [ [ "# take the source space from the forward model because some of the\n# vertices are excluded from the vertices in src\nn_dipoles = fwd['source_rr'].shape[0] # rr is the vertex positions\n# find the closest dipole to the one we used before (it was in this\n# source space) using the euclidean distance (np.linalg.norm)\nidx = np.argmin(np.linalg.norm(fwd['source_rr'] - dip_pos, axis=1))\n# make an empty matrix of zeros\ndata = np.zeros((n_dipoles, 3, 1))\ndata[idx, 2, 0] = 3e-8 # make the same dipole as before\n# this is the format that vertiex numbers are stored in\nvertices = [fwd['src'][0]['vertno']]\nstc = mne.VolVectorSourceEstimate(data, vertices=vertices,\n subject='sample', tmin=0, tstep=1)\n\nevoked = mne.simulation.simulate_evoked(\n fwd, stc, raw.info, cov=None, nave=np.inf)\n\n# confirm our replication\nfig, axes = plt.subplots(1, 3, figsize=(6, 4)) # make a figure with 3 subplots\nfor ax, ch_type in zip(axes, ('grad', 'mag', 'eeg')):\n evoked.plot_topomap(times=[0], ch_type=ch_type, axes=ax, colorbar=False)\n ax.set_title(ch_type)", "_____no_output_____" ] ], [ [ "Now, go crazy and simulate a bunch of random dipoles\n\n", "_____no_output_____" ] ], [ [ "np.random.seed(88) # always seed random number generation for reproducibility\nstc.data = np.random.random(stc.data.shape) * 3e-8 - 1.5e-8\nevoked = mne.simulation.simulate_evoked(\n fwd, stc, raw.info, cov=None, nave=np.inf)\n\n# now that's a complicated faked brain pattern, fortunately brain activity\n# is much more correlated (neighboring areas have similar activity) which\n# makes results a bit easier to interpret\nfig, axes = plt.subplots(1, 3, figsize=(6, 4)) # make a figure with 3 subplots\nfor ax, ch_type in zip(axes, ('grad', 'mag', 'eeg')):\n evoked.plot_topomap(times=[0], ch_type=ch_type, axes=ax, colorbar=False)\n ax.set_title(ch_type)", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ [ [ "from pymongo import MongoClient\n\ndb = MongoClient().argpedia['master']\n\ncard_hits = [i for i in db.find() if i['entry']['database']=='CARD']", "_____no_output_____" ], [ "# Genes in the card database used for training\nprint(f'Card Hits: {len(card_hits)}')", "Card Hits: 2355\n" ], [ "# subtract the labels from the gene names\nraw_labels = [i['entry']['subtype'] for i in card_hits]\nimport re\ndef get_gene_shape(s):\n replaced = re.sub(r'[A-Z]', 'X', s)\n replaced = re.sub(r'[a-z]', 'x', replaced)\n replaced = re.sub(r'[0-9]', 'N', replaced)\n replaced = re.sub('N+', 'N', replaced)\n return replaced\n\ndef get_info(alignments):\n data = []\n for alignment in alignments:\n if alignment['best_hit_database'] == 'CARD':\n try:\n data += [i['category_aro_name'] for i in alignment['metadata']]\n except:\n pass\n if alignment['best_hit_database'] == 'megares':\n data += [alignment['type'], alignment['subtype']]\n if alignment['best_hit_database'] == 'ARDB':\n try:\n data += [alignment['metadata']['subtype']] + [i['type'] for i in alignment['metadata']['resistance_profile']]\n except:\n data += [alignment['metadata']['subtype']]\n if alignment['best_hit_database'] == 'RESFINDER':\n data += [alignment['type'], alignment['subtype']]\n if alignment['best_hit_database'] == 'SARG':\n data += [alignment['type'], alignment['subtype']]\n if alignment['best_hit_database'] == 'ARG-ANNOT':\n data += [alignment['type'], alignment['subtype']]\n if alignment['best_hit_database'] == 'ncbi-arg':\n data += [alignment['type'], alignment['subtype']]\n \n return data\n\n \ny = [get_gene_shape(i) for i in raw_labels]\nX = [get_info(i['besthit']['alignments']) for i in card_hits]\n\nprint(f'Dataset: {len(X)}, Labels: {len(y)}')\n", "Dataset: 2355, Labels: 2355\n" ], [ "from sklearn.model_selection import train_test_split\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n\nfo = open('train.txt', 'w')\nfor ix,i in enumerate(X_train):\n fo.write(\" \".join([str(j) for j in i])+\"\\t__label__\"+y_train[ix]+'\\n')\n\nfo = open('test.txt', 'w')\nfor ix,i in enumerate(X_test):\n fo.write(\" \".join([str(j) for j in i])+\"\\t__label__\"+y_test[ix]+'\\n')", "_____no_output_____" ], [ "!fasttext supervised -input train.txt -output trained_model -epoch 10 -dim 100 -ws 3 -wordNgrams 2", "Read 0M words\nNumber of words: 4158\nNumber of labels: 77\nProgress: 100.0% words/sec/thread: 735058 lr: 0.000000 loss: 2.307008 eta: 0h0m 370295 eta: 0h0m eta: 0h0m \n" ], [ "!fasttext test trained_model.bin test.txt", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import svgwrite\nimport cairosvg", "_____no_output_____" ] ], [ [ "# Topics of Block Chain", "_____no_output_____" ] ], [ [ "_topics=[\n 'Philosophical: impact on society', \n 'Scientific: algorithms, computer science, math)', \n 'Commerce: changes to industry', \n 'Capital: risk / reward of allocation strategies',\n 'Mechanical: code, servers, data centers',\n]\n\n_w=300\n_h=50\n_s=10\n\n", "_____no_output_____" ], [ "svg_document = svgwrite.Drawing(filename = \"test-svgwrite.svg\",\n size = (\"800px\", \"600px\"))\n\nfor _index, _topic in enumerate(_topics): \n svg_document.add(\n svg_document.rect(\n insert = (\n 20,\n _s*(_index+1)+_h*_index,\n ),\n size = (\n '{:d}px'.format(_w), \n '{:d}px'.format(_h), \n ),\n stroke_width = '1',\n stroke = 'blue',\n fill = 'rgb(255,255,255)',\n ),\n )\n \n svg_document.add(\n svg_document.text(\n _topic,\n insert = (\n 30,\n _s*(_index+1)+_h*_index+28,\n ),\n style = 'font-size:10px; font-family:monospace'\n )\n )\n\n\nsvg_document.save()", "_____no_output_____" ], [ "with open('test.png', 'wb') as png_file:\n png_file.write(cairosvg.svg2png(url='test-svgwrite.svg'))", "_____no_output_____" ] ] ]

[ "code", "markdown", "code" ]

[ [ "code" ], [ "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import numpy\nfrom sklearn.neural_network import MLPClassifier\nfrom sklearn.externals import joblib", "_____no_output_____" ] ], [ [ "\n<ul>\n<li>Se inicializa una red neuronal usando función de activación de tangente hiperbólica, tasa de aprendizaje de 0.1 y 44 neuronas en capa oculta.</li>\n<li>Se entrena con dos instancias de entrenamiento (X e y) usando el método fit sobre la red neuronal.</li>\n</ul>\n", "_____no_output_____" ] ], [ [ "# Inicializo red neuronal con scikit\nclf = MLPClassifier(solver='lbfgs', activation='tanh', alpha=1e-4,\n hidden_layer_sizes=(44), random_state=1, learning_rate_init=.1)\n# Genero un array de vectores de input, de tamaño 64 y valores de [0,2]\nX = []\nfor i in range(4):\n X.append(numpy.random.randint(3, size=64))\n# X = numpy.random.randint(3, size=64).tolist()\n# X.append(5)\n# X.append(4)\n# X = X.reshape(1,-1)\ny = [0, 1, -1, 0]\n# Se entrena con X e Y a la red\nclf.fit(X, y)\nX = []\nfor i in range(4):\n X.append(numpy.random.randint(3, size=64))\ny = [-1, 0, -1, 1]\n# Se entrena nuevamente\nclf.fit(X, y)\n# clf.predict([[0., 0.], [1., 1.], [2., 1.], [1., 2.], [0., 1.5]])", "_____no_output_____" ] ], [ [ "Ejemplo de cómo evaluar un vector de entrada nuevo (lo que sería un tablero de Othello) con la red neuronal.", "_____no_output_____" ] ], [ [ "newBoard = numpy.random.randint(3, size=64)\nnewBoard = newBoard.reshape(1,-1)\nclf.predict(newBoard)", "_____no_output_____" ] ], [ [ "Ejemplo de como persistir red neuronal entrenada a un archivo en la ruta del notebook.", "_____no_output_____" ] ], [ [ "neuralNetwork = MLPClassifier(solver='lbfgs', activation='tanh', alpha=1e-4,\n hidden_layer_sizes=(44), random_state=1, learning_rate_init=.1)\njoblib.dump(neuralNetwork, 'red-neuronal-test.pkl')", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "# Segmentation \n\nThis notebook shows how to use Stardist (Object Detection with Star-convex Shapes) as a part of a segmentation-classification-tracking analysis pipeline. \n\nThe sections of this notebook are as follows:\n\n1. Load images\n2. Load model of choice and segment an initial image to test Stardist parameters\n3. Batch segment a sequence of images\n\nThe data used in this notebook is timelapse microscopy data with h2b-gfp/rfp markers that show the spatial extent of the nucleus and it's mitotic state. \n\nThis notebook uses the dask octopuslite image loader from the CellX/Lowe lab project.", "_____no_output_____" ] ], [ [ "import matplotlib.pyplot as plt\nimport numpy as np\nimport os\nfrom octopuslite import DaskOctopusLiteLoader\nfrom stardist.models import StarDist2D \nfrom stardist.plot import render_label\nfrom csbdeep.utils import normalize\nfrom tqdm.auto import tqdm\nfrom skimage.io import imsave\nimport json\nfrom scipy import ndimage as nd", "_____no_output_____" ], [ "%matplotlib inline\nplt.rcParams['figure.figsize'] = [18,8]", "_____no_output_____" ] ], [ [ "## 1. Load images", "_____no_output_____" ] ], [ [ "# define experiment ID and select a position\nexpt = 'ND0011'\npos = 'Pos6'\n# point to where the data is\nroot_dir = '/home/nathan/data'\nimage_path = f'{root_dir}/{expt}/{pos}/{pos}_images'\n# lazily load imagesdd\nimages = DaskOctopusLiteLoader(image_path, \n remove_background = True)\nimages.channels", "Using cropping: (1200, 1600)\n" ] ], [ [ "Set segmentation channel and load test image", "_____no_output_____" ] ], [ [ "# segmentation channel\nsegmentation_channel = images.channels[3]\n# set test image index\nframe = 1000\n# load test image \nirfp = images[segmentation_channel.name][frame].compute()\n# create 1-channel XYC image\nimg = np.expand_dims(irfp, axis = -1)\nimg.shape", "_____no_output_____" ] ], [ [ "## 2. Load model and test segment single image ", "_____no_output_____" ] ], [ [ "model = StarDist2D.from_pretrained('2D_versatile_fluo')\nmodel", "Found model '2D_versatile_fluo' for 'StarDist2D'.\nLoading network weights from 'weights_best.h5'.\nLoading thresholds from 'thresholds.json'.\nUsing default values: prob_thresh=0.479071, nms_thresh=0.3.\n" ] ], [ [ "### 2.1 Test run and display initial results", "_____no_output_____" ] ], [ [ "# initialise test segmentation\nlabels, details = model.predict_instances(normalize(img))\n\n# plot input image and prediction\nplt.clf()\nplt.subplot(1,2,1)\nplt.imshow(normalize(img[:,:,0]), cmap=\"PiYG\")\nplt.axis(\"off\")\nplt.title(\"input image\")\nplt.subplot(1,2,2)\nplt.imshow(render_label(labels, img = img))\nplt.axis(\"off\")\nplt.title(\"prediction + input overlay\")\nplt.show()", "Clipping input data to the valid range for imshow with RGB data ([0..1] for floats or [0..255] for integers).\n" ] ], [ [ "## 3. Batch segment a whole stack of images", "_____no_output_____" ], [ "When you segment a whole data set you do not want to apply any image transformation. This is so that when you load images and masks later on you can apply the same transformation. You can apply a crop but note that you need to be consistent with your use of the crop from this point on, otherwise you'll get a shift. ", "_____no_output_____" ] ], [ [ "for expt in tqdm(['ND0009', 'ND0010', 'ND0011']):\n for pos in tqdm(['Pos0', 'Pos1', 'Pos2', 'Pos3', 'Pos4']):\n print('Starting experiment position:', expt, pos)\n # load images\n image_path = f'{root_dir}/{expt}/{pos}/{pos}_images'\n images = DaskOctopusLiteLoader(image_path, \n remove_background = True)\n # iterate over images filenames \n for fn in tqdm(images.files(segmentation_channel.name)):\n # compile 1-channel into XYC array\n img = np.expand_dims(imread(fn), axis = -1)\n # predict labels\n labels, details = model.predict_instances(normalize(img))\n # set filename as mask format (channel099)\n fn = fn.replace(f'channel00{segmentation_channel.value}', 'channel099')\n # save out labelled image\n imsave(fn, labels.astype(np.uint16), check_contrast=False)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ] ]

[ "Unlicense" ]

[ "Unlicense" ]

[ "Unlicense" ]

[ [ [ "# Introduction to Language Processing Concepts\n### Original tutorial by Brain Lehman, with updates by Fiona Pigott\n\nThe goal of this tutorial is to introduce a few basical vocabularies, ideas, and Python libraries for thinking about topic modeling, in order to make sure that we have a good set of vocabulary to talk more in-depth about processing languge with Python later. We'll spend some time on defining vocabulary for topic modeling and using basic topic modeling tools.\n\nA big thank-you to the good people at the Stanford NLP group, for their informative and helpful online book: https://nlp.stanford.edu/IR-book/.\n\n### Definitions.\n1. **Document**: a body of text (eg. tweet)\n2. **Tokenization**: dividing a document into pieces (and maybe throwing away some characters), in English this often (but not necessarily) means words separated by spaces and puctuation.\n3. **Text corpus**: the set of documents that contains the text for the analysis (eg. many tweets)\n4. **Stop words**: words that occur so frequently, or have so little topical meaning, that they are excluded (e.g., \"and\")\n5. **Vectorize**: Turn some documents into vectors\n6. **Vector corpus**: the set of documents transformed such that each token is a tuple (token_id , doc_freq)", "_____no_output_____" ] ], [ [ "# first, get some text:\nimport fileinput\ntry:\n import ujson as json\nexcept ImportError:\n import json\ndocuments = []\nfor line in fileinput.FileInput(\"example_tweets.json\"):\n documents.append(json.loads(line)[\"text\"])", "_____no_output_____" ] ], [ [ "### 1) Document\nIn the case of the text that we just imported, each entry in the list is a \"document\"--a single body of text, hopefully with some coherent meaning.", "_____no_output_____" ] ], [ [ "print(\"One document: \\\"{}\\\"\".format(documents[0]))", "_____no_output_____" ] ], [ [ "### 2) Tokenization\nWe split each document into smaller pieces (\"tokens\") in a process called tokenization. Tokens can be counted, and most importantly, compared between documents. There are potentially many different ways to tokenize text--splitting on spaces, removing punctionation, diving the document into n-character pieces--anything that gives us tokens that we can, hopefully, effectively compare across documents and derive meaning from.\n\nRelated to tokenization are processes called *stemming* and *lemmatiztion* which can help when using tokens to model topics based on the meaning of a word. In the phrases \"they run\" and \"he runs\" (space separated tokens: [\"they\", \"run\"] and [\"he\", \"runs\"]) the words \"run\" and \"run*s*\" mean basically the same thing, but are two different tokens. Stemming and/or lemmatization help us compare tokens with the same meaning but different spelling/suffixes.\n\n#### Lemmatization:\nUses a dictionary of words and their possible morphologies to map many different forms of a base word (\"lemma\") to a single lemma, comparable across documents. E.g.: \"run\", \"ran\", \"runs\", and \"running\" might all map to the lemma \"run\"\n\n#### Stemming: \nUses a set of heuristic rules to try to approximate lemmatization, without knowing the words in advance. For the English language, a simple and effective stemming algorithm might simply be to remove an \"s\" from the ends of words, or an \"ing\" from the end of words. E.g.: \"run\", \"runs\", and \"running\" all map to \"run,\" but \"ran\" (an irregularrly conjugated verb) would not. \n\nStemming is particularly interesting and applicable in social data, because while some words are decidely *not* standard English, conventinoal rules of grammar still apply. A fan of the popular singer Justin Bieber might call herself a \"belieber,\" while a group of fans call themselves \"beliebers.\" You won't find \"belieber\" in any English lemmatization dictionary, but a good stemming algorithm will still map \"belieber\" and \"beliebers\" to the same token (\"belieber\", or even \"belieb\", if we remover the common suffix \"er\").", "_____no_output_____" ] ], [ [ "from nltk.stem import porter\nfrom nltk.tokenize import TweetTokenizer\n\n# tokenize the documents\n# find good information on tokenization:\n# https://nlp.stanford.edu/IR-book/html/htmledition/tokenization-1.html\n# find documentation on pre-made tokenizers and options here:\n# http://www.nltk.org/api/nltk.tokenize.html\ntknzr = TweetTokenizer(reduce_len = True)\n\n# stem the documents\n# find good information on stemming and lemmatization:\n# https://nlp.stanford.edu/IR-book/html/htmledition/stemming-and-lemmatization-1.html\n# find documentation on available pre-implemented stemmers here:\n# http://www.nltk.org/api/nltk.stem.html\nstemmer = porter.PorterStemmer()\nfor doc in documents[0:10]:\n tokenized = tknzr.tokenize(doc)\n stemmed = [stemmer.stem(x) for x in tokenized]\n print(\"Original document:\\n{}\\nTokenized result:\\n{}\\nStemmed result:\\n{}\\n\".format(\n doc, tokenized, stemmed))", "_____no_output_____" ] ], [ [ "### 3) Text corpus\n\nThe text corpus is a collection of all of the documents (Tweets) that we're interested in modeling. Topic modeling and/or clustering on a corpus tends to work best if that corpus has some similar themes--this will mean that some tokens overlap, and we can get signal out of when documents share (or do not share) tokens. \n\nModeling text tends to get much harder the more different, uncommon and unrelated tokens appear in a text, especially when we are working with social data, where tokens don't necessarily appear in a dictionary. This difficultly (of having many, many unrelated tokens as dimension in our model) is one example of the [curse of dimensionality](https://en.wikipedia.org/wiki/Curse_of_dimensionality).", "_____no_output_____" ] ], [ [ "# number of documents in the corpus\nprint(\"There are {} documents in the corpus.\".format(len(documents)))", "_____no_output_____" ] ], [ [ "### 4) Stop words:\nStop words are simply tokens that we've chosen to remove from the corpus, for any reason. In English, removing words like \"and\", \"the\", \"a\", \"at\", and \"it\" are common choices for stop words. Stop words can also be edited per project requirement, in case some words are too common in a particular dataset to be meaningful (another way to do stop word removal is to simply remove any word that appears in more than some fixed percentage of documents).", "_____no_output_____" ] ], [ [ "from nltk.corpus import stopwords\n\nstopset = set(stopwords.words('english'))\nprint(\"The English stop words list provided by NLTK: \")\nprint(stopset)\n\nstopset.update([\"twitter\"]) # add token\nstopset.remove(\"i\") # remove token\nprint(\"\\nAdd or remove stop words form the set: \")\nprint(stopset)", "_____no_output_____" ] ], [ [ "### 5) Vectorize:\n\nTransform each document into a vector. There are several good choices that you can make about how to do this transformation, and I'll talk about each of them in a second.\n\nIn order to vectorize documents in a corpus (without any dimensional reduction around the vocabulary), think of each document as a row in a matrix, and each column as a word in the vocabulary of the entire corpus. In order to vectorize a corpus, we must read the entire corpus, assign one word to each column, and then turn each document into a row.\n\n**Example**: \n**Documents**: \"I love cake\", \"I hate chocolate\", \"I love chocolate cake\", \"I love cake, but I hate chocolate cake\" \n**Stopwords**: Say, because the word \"but\" is a conjunction, we want to make it a stop word (not include it in our document vectors)\n**Vocabulary**: \"I\" (column 1), \"love\" (column 2), \"cake\" (column 3), \"hate\" (column 4), \"chocolate\" (column 5)\n\\begin{equation*}\n\\begin{matrix}\n\\text{\"I love cake\" } & =\\\\\n\\text{\"I hate chocolate\" } & =\\\\\n\\text{\"I love chocolate cake\" } & = \\\\\n\\text{\"I love cake, but I hate chocolate cake\"} & =\n\\end{matrix}\n\\qquad\n\\begin{bmatrix}\n1 & 1 & 1 & 0 & 0\\\\\n1 & 0 & 0 & 1 & 1\\\\\n1 & 1 & 1 & 0 & 1\\\\\n2 & 1 & 2 & 1 & 1\n\\end{bmatrix}\n\\end{equation*}\n\n\nVectorization like this don't take into account word order (we call this property \"bag of words\"), and in the above example I am simply counting the frequency of each term in each document.", "_____no_output_____" ] ], [ [ "# we're going to use the vectorizer functions that scikit learn provides\n\n# define the tokenizer that we want to use\n# must be a callable function that takes a document and returns a list of tokens\ntknzr = TweetTokenizer(reduce_len = True)\nstemmer = porter.PorterStemmer()\ndef myTokenizer(doc):\n return [stemmer.stem(x) for x in tknzr.tokenize(doc)]\n\n# choose the stopword set that we want to use\nstopset = set(stopwords.words('english'))\nstopset.update([\"http\",\"https\",\"twitter\",\"amp\"])\n\n# vectorize\n# we're using the scikit learn CountVectorizer function, which is very handy\n# documentation here: \n# http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.CountVectorizer.html\nfrom sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\nvectorizer = CountVectorizer(tokenizer = myTokenizer, stop_words = stopset)\nvectorized_documents = vectorizer.fit_transform(documents)", "_____no_output_____" ], [ "vectorized_documents", "_____no_output_____" ], [ "import matplotlib.pyplot as plt\n%matplotlib inline\n_ = plt.hist(vectorized_documents.todense().sum(axis = 1))\n_ = plt.title(\"Number of tokens per document\")\n_ = plt.xlabel(\"Number of tokens\")\n_ = plt.ylabel(\"Number of documents with x tokens\")", "_____no_output_____" ], [ "from numpy import logspace, ceil, histogram, array\n# get the token frequency\ntoken_freq = sorted(vectorized_documents.todense().astype(bool).sum(axis = 0).tolist()[0], reverse = False)\n# make a histogram with log scales\nbins = array([ceil(x) for x in logspace(0, 3, 5)])\nwidths = (bins[1:] - bins[:-1])\nhist = histogram(token_freq, bins=bins)\nhist_norm = hist[0]/widths\n# plot (notice that most tokens only appear in one document)\nplt.bar(bins[:-1], hist_norm, widths)\nplt.xscale('log')\nplt.yscale('log')\n_ = plt.title(\"Number of documents in which each token appears\")\n_ = plt.xlabel(\"Number of documents\")\n_ = plt.ylabel(\"Number of tokens\")", "_____no_output_____" ] ], [ [ "#### Bag of words\nTaking all the words from a document, and sticking them in a bag. Order does not matter, which could cause a problem. \"Alice loves cake\" might have a different meaning than \"Cake loves Alice.\"\n\n#### Frequency\nCounting the number of times a word appears in a document.\n\n#### Tf-Idf (term frequency inverse document frequency):\nA statistic that is intended to reflect how important a word is to a document in a collection or corpus. The Tf-Idf value increases proportionally to the number of times a word appears in the document and is inversely proportional to the frequency of the word in the corpus--this helps control words that are generally more common than others. \n\nThere are several different possibilities for computing the tf-idf statistic--choosing whether to normalize the vectors, choosing whether to use counts or the logarithm of counts, etc. I'm going to show how scikit-learn computed the tf-idf statistic by default, with more information available in the documentation of the sckit-learn [TfidfVectorizer](http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfTransformer.html).\n\n$tf(t)$ : Term Frequency, count of the number of times each term appears in the document. \n$idf(d,t)$ : Inverse document frequency. \n$df(d,t)$ : Document frequency, the count of the number of documents in which the term appears. \n\n$$\ntfidf(t) = tf(t) * \\log\\big(\\frac{1 + n}{1 + df(d, t)}\\big) + 1\n$$\n\nWe also then take the Euclidean ($l2$) norm of each document vector, so that long documents (documents with many non-stopword tokens) have the same norm as shorter documents.", "_____no_output_____" ] ], [ [ "# documentation on this sckit-learn function here:\n# http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfTransformer.html\ntfidf_vectorizer = TfidfVectorizer(tokenizer = myTokenizer, stop_words = stopset)\ntfidf_vectorized_documents = tfidf_vectorizer.fit_transform(documents)", "_____no_output_____" ], [ "tfidf_vectorized_documents", "_____no_output_____" ], [ "# you can look at two vectors for the same document, from 2 different vectorizers:\ntfidf_vectorized_documents[0].todense().tolist()[0]", "_____no_output_____" ], [ "vectorized_documents[0].todense().tolist()[0]", "_____no_output_____" ] ], [ [ "## That's all for now!", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "[View in Colaboratory](https://colab.research.google.com/github/kartikeyab/Kaggle-Codes/blob/master/MovieReviews.ipynb)", "_____no_output_____" ] ], [ [ "from keras.preprocessing.text import Tokenizer \ntokenizer = Tokenizer(num_words = 10000)\nimport pandas as pd\nimport numpy as np\nfrom keras.utils import to_categorical\n", "Using TensorFlow backend.\n" ], [ "from google.colab import files\nuploaded = files.upload()", "_____no_output_____" ], [ "#loading data\ntrain_df = pd.read_csv('train.tsv', sep='\\t', header=0)\n", "_____no_output_____" ], [ "x_train = train_df['Phrase'].values\ny_train = train_df['Sentiment'].values\n", "_____no_output_____" ], [ "x_train[1000] , y_train[1000]", "_____no_output_____" ], [ "tokenizer.fit_on_texts(x_train)\ntokenizer.word_index\nx_train_tokens = tokenizer.texts_to_sequences(x_train)\ny_train = to_categorical(y_train)\n\n", "_____no_output_____" ], [ "x_train[7] , y_train[7]", "_____no_output_____" ], [ "num_token = [ len(x) for x in x_train]\nnum_token = np.array(num_token)\n", "_____no_output_____" ], [ "max_tokens = np.mean(num_token) + 2*np.std(num_token)\nprint(max_tokens)", "116.52523938435769\n" ], [ "from keras.preprocessing.sequence import pad_sequences", "_____no_output_____" ], [ "x_train_pad = pad_sequences(x_train_tokens, maxlen = 116 , padding = 'pre')\nx_train_pad[1]", "_____no_output_____" ], [ "from keras.models import Sequential\nfrom keras.layers import Embedding , Dense , Conv1D , MaxPooling1D , GRU, LSTM , Flatten , Dropout\nfrom keras.optimizers import adagrad\n", "_____no_output_____" ], [ "num_classes = 5\n", "_____no_output_____" ], [ "model = Sequential()\nmodel.add(Embedding(input_dim = 10000, input_length = 116 ,output_dim = 128))\n\nmodel.add(Conv1D(128 , kernel_size = 3 , activation = 'relu'))\n\nmodel.add(Conv1D(64 , kernel_size = 3 , activation = 'relu'))\n\nmodel.add(MaxPooling1D(pool_size =2))\n\nmodel.add(Dropout(0.2))\n\nmodel.add(Flatten())\n\nmodel.add(Dense(250))\n\n\n\nmodel.add(Dense(num_classes, activation = 'sigmoid'))\n\n\nmodel.compile(loss = 'categorical_crossentropy', optimizer = 'adam', metrics = ['accuracy'])\n\nmodel.summary()", "_________________________________________________________________\nLayer (type) Output Shape Param # \n=================================================================\nembedding_18 (Embedding) (None, 116, 128) 1280000 \n_________________________________________________________________\nconv1d_28 (Conv1D) (None, 114, 128) 49280 \n_________________________________________________________________\nconv1d_29 (Conv1D) (None, 112, 64) 24640 \n_________________________________________________________________\nmax_pooling1d_18 (MaxPooling (None, 56, 64) 0 \n_________________________________________________________________\ndropout_9 (Dropout) (None, 56, 64) 0 \n_________________________________________________________________\nflatten_11 (Flatten) (None, 3584) 0 \n_________________________________________________________________\ndense_31 (Dense) (None, 250) 896250 \n_________________________________________________________________\ndense_32 (Dense) (None, 5) 1255 \n=================================================================\nTotal params: 2,251,425\nTrainable params: 2,251,425\nNon-trainable params: 0\n_________________________________________________________________\n" ], [ "model.fit(x_train_pad, y_train ,validation_split = 0.2, epochs = 10, batch_size = 256, shuffle = True)", "Train on 124848 samples, validate on 31212 samples\nEpoch 1/10\n124848/124848 [==============================] - 16s 125us/step - loss: 1.0302 - acc: 0.5819 - val_loss: 1.0066 - val_acc: 0.5970\nEpoch 2/10\n112896/124848 [==========================>...] - ETA: 1s - loss: 0.8050 - acc: 0.6636" ], [ "", "_____no_output_____" ], [ "", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

[ [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/saanaz379/user-comment-classifier/blob/main/solution_1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ], [ "This is the first of three solutions to identify offensive language or hate speech in a set of user comments. The code is tested on actual data provided from a day's user comments. This solution utilizes a dictionary that stores all common offensive words and identifies them in any given review, which is then flagged for review. The dictionary is extracted from a Kaggle dataset of offensive tweets.\n\n*Note: This code is incapable of detecting sentence patterns that may predict hate speech.", "_____no_output_____" ] ], [ [ "! pip install nltk", "Requirement already satisfied: nltk in /usr/local/lib/python3.7/dist-packages (3.2.5)\nRequirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from nltk) (1.15.0)\n" ], [ "! python -m textblob.download_corpora", "[nltk_data] Downloading package brown to /root/nltk_data...\n[nltk_data] Unzipping corpora/brown.zip.\n[nltk_data] Downloading package punkt to /root/nltk_data...\n[nltk_data] Unzipping tokenizers/punkt.zip.\n[nltk_data] Downloading package wordnet to /root/nltk_data...\n[nltk_data] Unzipping corpora/wordnet.zip.\n[nltk_data] Downloading package averaged_perceptron_tagger to\n[nltk_data] /root/nltk_data...\n[nltk_data] Unzipping taggers/averaged_perceptron_tagger.zip.\n[nltk_data] Downloading package conll2000 to /root/nltk_data...\n[nltk_data] Unzipping corpora/conll2000.zip.\n[nltk_data] Downloading package movie_reviews to /root/nltk_data...\n[nltk_data] Unzipping corpora/movie_reviews.zip.\nFinished.\n" ], [ "import nltk\nimport csv\nimport collections\nimport pandas as pd\n\nfrom collections import Counter\nfrom nltk.corpus import stopwords", "_____no_output_____" ], [ "# extracting offensive language from twitter kaggle data to final_list\n\nnltk.download('stopwords')\nraw_reviews = []\nreviews_filename = '/content/drive/MyDrive/labeled_data.csv'\nwith open(reviews_filename, 'r') as reviews_csvfile:\n csvreader = csv.reader(reviews_csvfile)\n next(csvreader)\n for i in range(1000): # 10399\n row = next(csvreader)\n if int(row[3]) != 0:\n review = row[-1]\n review_arr = review.split(\":\")\n raw_reviews.append(review_arr[-1])\nreview_words = []\nfor review in raw_reviews:\n review_arr = review.split(\" \")\n for review_word in review_arr:\n if \"\\\"\" not in review_word and review_word != \"\" and not \"&\" in review_word and review_word != \"-\" and review_word != \"love\" and \"I\" not in review_word and \"'\" not in review_word and review_word != \"got\":\n review_words.append(review_word)\nstop_words = set(stopwords.words('english'))\nwith open('/content/drive/MyDrive/common_words.txt','r') as file:\n common_words = file.read()\nwords_list = [word for word in review_words if not word in stop_words and not word in common_words]\nfinal_list = []\nfor word in Counter(words_list).most_common(9):\n final_list.append(word[0])", "[nltk_data] Downloading package stopwords to /root/nltk_data...\n[nltk_data] Package stopwords is already up-to-date!\n" ], [ "# adding reviews to formatted Data Frame\n\nraw_reviews = []\nreviews_filename = '/content/drive/MyDrive/reviews.csv.txt'\nwith open(reviews_filename, 'r') as reviews_csvfile:\n csvreader = csv.reader(reviews_csvfile)\n next(csvreader)\n next(csvreader)\n for i in range(10397):\n row = next(csvreader)\n if (len(row) >= 5):\n row.pop(0)\n row.pop(-1)\n row[2] = ''.join(row[2].split())\n if row[2].replace('.', '', 1).isdigit():\n row[2] = float(row[2])\n row[1] = row[1].rstrip()\n if not row[1] == \"\" and isinstance(row[2], float):\n raw_reviews.append(row)\ntable = pd.DataFrame(data = raw_reviews, columns = ['ID', 'Comments', 'Recommend'])\ntable", "_____no_output_____" ], [ "# Return flagged comments for human review. In\n# this case, the comments marked only contain\n# contain words that are made up of a word in the\n# dictionary.\n\nfor col, row in table.iterrows():\n curr_review = row['Comments']\n for word in final_list:\n word = word + \".\"\n if word in curr_review:\n print(\"offensive lang\")\n print(curr_review)", "offensive lang\n She was very quick and informative. No bullshit. You could tell she had a smile even with her mask. Thanks!\n" ] ] ]

[ "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code", "code" ] ]

[ "CC-BY-4.0", "BSD-3-Clause" ]

[ "CC-BY-4.0", "BSD-3-Clause" ]

[ "CC-BY-4.0", "BSD-3-Clause" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/NeuromatchAcademy/course-content/blob/master/tutorials/W1D3_ModelFitting/W1D3_Tutorial3.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ], [ "\n# Neuromatch Academy: Week 1, Day 3, Tutorial 3\n# Model Fitting: Confidence intervals and bootstrapping\n\n**Content creators**: Pierre-Étienne Fiquet, Anqi Wu, Alex Hyafil with help from Byron Galbraith\n\n**Content reviewers**: Lina Teichmann, Saeed Salehi, Patrick Mineault, Ella Batty, Michael Waskom ", "_____no_output_____" ], [ "#Tutorial Objectives\n\nThis is Tutorial 3 of a series on fitting models to data. We start with simple linear regression, using least squares optimization (Tutorial 1) and Maximum Likelihood Estimation (Tutorial 2). We will use bootstrapping to build confidence intervals around the inferred linear model parameters (Tutorial 3). We'll finish our exploration of regression models by generalizing to multiple linear regression and polynomial regression (Tutorial 4). We end by learning how to choose between these various models. We discuss the bias-variance trade-off (Tutorial 5) and Cross Validation for model selection (Tutorial 6).\n\nIn this tutorial, we wil discuss how to gauge how good our estimated model parameters are. \n- Learn how to use bootstrapping to generate new sample datasets\n- Estimate our model parameter on these new sample datasets\n- Quantify the variance of our estimate using confidence intervals", "_____no_output_____" ] ], [ [ "#@title Video 1: Confidence Intervals & Bootstrapping\nfrom IPython.display import YouTubeVideo\nvideo = YouTubeVideo(id=\"hs6bVGQNSIs\", width=854, height=480, fs=1)\nprint(\"Video available at https://youtube.com/watch?v=\" + video.id)\nvideo", "_____no_output_____" ] ], [ [ "Up to this point we have been finding ways to estimate model parameters to fit some observed data. Our approach has been to optimize some criterion, either minimize the mean squared error or maximize the likelihood while using the entire dataset. How good is our estimate really? How confident are we that it will generalize to describe new data we haven't seen yet?\n\nOne solution to this is to just collect more data and check the MSE on this new dataset with the previously estimated parameters. However this is not always feasible and still leaves open the question of how quantifiably confident we are in the accuracy of our model.\n\nIn Section 1, we will explore how to implement bootstrapping. In Section 2, we will build confidence intervals of our estimates using the bootstrapping method.", "_____no_output_____" ], [ "---\n# Setup", "_____no_output_____" ] ], [ [ "import numpy as np\nimport matplotlib.pyplot as plt", "_____no_output_____" ], [ "#@title Figure Settings\n%config InlineBackend.figure_format = 'retina'\nplt.style.use(\"https://raw.githubusercontent.com/NeuromatchAcademy/course-content/master/nma.mplstyle\")", "_____no_output_____" ], [ "#@title Helper Functions\ndef solve_normal_eqn(x, y):\n \"\"\"Solve the normal equations to produce the value of theta_hat that minimizes\n MSE.\n\n Args:\n x (ndarray): An array of shape (samples,) that contains the input values.\n y (ndarray): An array of shape (samples,) that contains the corresponding\n measurement values to the inputs.\n thata_hat (float): An estimate of the slope parameter.\n\n Returns:\n float: the value for theta_hat arrived from minimizing MSE\n \"\"\"\n theta_hat = (x.T @ y) / (x.T @ x)\n return theta_hat", "_____no_output_____" ] ], [ [ "---\n# Section 1: Bootstrapping\n\n[Bootstrapping](https://en.wikipedia.org/wiki/Bootstrapping_(statistics)) is a widely applicable method to assess confidence/uncertainty about estimated parameters, it was originally [proposed](https://projecteuclid.org/euclid.aos/1176344552) by [Bradley Efron](https://en.wikipedia.org/wiki/Bradley_Efron). The idea is to generate many new synthetic datasets from the initial true dataset by randomly sampling from it, then finding estimators for each one of these new datasets, and finally looking at the distribution of all these estimators to quantify our confidence.\n\nNote that each new resampled datasets will be the same size as our original one, with the new data points sampled with replacement i.e. we can repeat the same data point multiple times. Also note that in practice we need a lot of resampled datasets, here we use 2000.\n\nTo explore this idea, we will start again with our noisy samples along the line $y_n = 1.2x_n + \\epsilon_n$, but this time only use half the data points as last time (15 instead of 30).", "_____no_output_____" ] ], [ [ "#@title\n\n#@markdown Execute this cell to simulate some data\n\n# setting a fixed seed to our random number generator ensures we will always\n# get the same psuedorandom number sequence\nnp.random.seed(121)\n\n# Let's set some parameters\ntheta = 1.2\nn_samples = 15\n\n# Draw x and then calculate y\nx = 10 * np.random.rand(n_samples) # sample from a uniform distribution over [0,10)\nnoise = np.random.randn(n_samples) # sample from a standard normal distribution\ny = theta * x + noise\n\nfig, ax = plt.subplots()\nax.scatter(x, y) # produces a scatter plot\nax.set(xlabel='x', ylabel='y');", "_____no_output_____" ] ], [ [ "### Exercise 1: Resample Dataset with Replacement\n\nIn this exercise you will implement a method to resample a dataset with replacement. The method accepts $x$ and $y$ arrays. It should return a new set of $x'$ and $y'$ arrays that are created by randomly sampling from the originals.\n\nWe will then compare the original dataset to a resampled dataset.\n\nTIP: The [numpy.random.choice](https://numpy.org/doc/stable/reference/random/generated/numpy.random.choice.html) method would be useful here.", "_____no_output_____" ] ], [ [ "def resample_with_replacement(x, y):\n \"\"\"Resample data points with replacement from the dataset of `x` inputs and\n `y` measurements.\n\n Args:\n x (ndarray): An array of shape (samples,) that contains the input values.\n y (ndarray): An array of shape (samples,) that contains the corresponding\n measurement values to the inputs.\n\n Returns:\n ndarray, ndarray: The newly resampled `x` and `y` data points.\n \"\"\"\n #######################################################\n ## TODO for students: resample dataset with replacement\n # Fill out function and remove\n raise NotImplementedError(\"Student exercise: resample dataset with replacement\")\n #######################################################\n\n # Get array of indices for resampled points\n sample_idx = ...\n\n # Sample from x and y according to sample_idx\n x_ = ...\n y_ = ...\n return x_, y_\n\n\nfig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12, 5))\nax1.scatter(x, y)\nax1.set(title='Original', xlabel='x', ylabel='y')\n\n# Uncomment below to test your function\n#x_, y_ = resample_with_replacement(x, y)\n#ax2.scatter(x_, y_, color='c')\n\nax2.set(title='Resampled', xlabel='x', ylabel='y',\n xlim=ax1.get_xlim(), ylim=ax1.get_ylim());", "_____no_output_____" ], [ "# to_remove solution\ndef resample_with_replacement(x, y):\n \"\"\"Resample data points with replacement from the dataset of `x` inputs and\n `y` measurements.\n\n Args:\n x (ndarray): An array of shape (samples,) that contains the input values.\n y (ndarray): An array of shape (samples,) that contains the corresponding\n measurement values to the inputs.\n\n Returns:\n ndarray, ndarray: The newly resampled `x` and `y` data points.\n \"\"\"\n\n # Get array of indices for resampled points\n sample_idx = np.random.choice(len(x), size=len(x), replace=True)\n\n # Sample from x and y according to sample_idx\n x_ = x[sample_idx]\n y_ = y[sample_idx]\n\n return x_, y_\n\n\nwith plt.xkcd():\n fig, (ax1, ax2) = plt.subplots(ncols=2, figsize=(12, 5))\n ax1.scatter(x, y)\n ax1.set(title='Original', xlabel='x', ylabel='y')\n\n x_, y_ = resample_with_replacement(x, y)\n ax2.scatter(x_, y_, color='c')\n\n ax2.set(title='Resampled', xlabel='x', ylabel='y',\n xlim=ax1.get_xlim(), ylim=ax1.get_ylim());", "_____no_output_____" ] ], [ [ "In the resampled plot on the right, the actual number of points is the same, but some have been repeated so they only display once.\n\nNow that we have a way to resample the data, we can use that in the full bootstrapping process.", "_____no_output_____" ], [ "### Exercise 2: Bootstrap Estimates\n\nIn this exercise you will implement a method to run the bootstrap process of generating a set of $\\hat\\theta$ values from a dataset of $x$ inputs and $y$ measurements. You should use `resample_with_replacement` here, and you may also invoke helper function `solve_normal_eqn` from Tutorial 1 to produce the MSE-based estimator.\n\nWe will then use this function to look at the theta_hat from different samples.\n", "_____no_output_____" ] ], [ [ "def bootstrap_estimates(x, y, n=2000):\n \"\"\"Generate a set of theta_hat estimates using the bootstrap method.\n\n Args:\n x (ndarray): An array of shape (samples,) that contains the input values.\n y (ndarray): An array of shape (samples,) that contains the corresponding\n measurement values to the inputs.\n n (int): The number of estimates to compute\n\n Returns:\n ndarray: An array of estimated parameters with size (n,)\n \"\"\"\n theta_hats = np.zeros(n)\n\n ##############################################################################\n ## TODO for students: implement bootstrap estimation\n # Fill out function and remove\n raise NotImplementedError(\"Student exercise: implement bootstrap estimation\")\n ##############################################################################\n\n # Loop over number of estimates\n for i in range(n):\n\n # Resample x and y\n x_, y_ = ...\n\n # Compute theta_hat for this sample\n theta_hats[i] = ...\n\n return theta_hats\n\n\nnp.random.seed(123) # set random seed for checking solutions\n\n# Uncomment below to test function\n# theta_hats = bootstrap_estimates(x, y, n=2000)\n# print(theta_hats[0:5])", "_____no_output_____" ], [ "# to_remove solution\ndef bootstrap_estimates(x, y, n=2000):\n \"\"\"Generate a set of theta_hat estimates using the bootstrap method.\n\n Args:\n x (ndarray): An array of shape (samples,) that contains the input values.\n y (ndarray): An array of shape (samples,) that contains the corresponding\n measurement values to the inputs.\n n (int): The number of estimates to compute\n\n Returns:\n ndarray: An array of estimated parameters with size (n,)\n \"\"\"\n theta_hats = np.zeros(n)\n\n # Loop over number of estimates\n for i in range(n):\n\n # Resample x and y\n x_, y_ = resample_with_replacement(x, y)\n\n # Compute theta_hat for this sample\n theta_hats[i] = solve_normal_eqn(x_, y_)\n\n return theta_hats\n\n\nnp.random.seed(123) # set random seed for checking solutions\n\ntheta_hats = bootstrap_estimates(x, y, n=2000)\nprint(theta_hats[0:5])", "_____no_output_____" ] ], [ [ "You should see `[1.27550888 1.17317819 1.18198819 1.25329255 1.20714664]` as the first five estimates.", "_____no_output_____" ], [ "Now that we have our bootstrap estimates, we can visualize all the potential models (models computed with different resampling) together to see how distributed they are.", "_____no_output_____" ] ], [ [ "#@title\n#@markdown Execute this cell to visualize all potential models\n\nfig, ax = plt.subplots()\n\n# For each theta_hat, plot model\ntheta_hats = bootstrap_estimates(x, y, n=2000)\nfor i, theta_hat in enumerate(theta_hats):\n y_hat = theta_hat * x\n ax.plot(x, y_hat, c='r', alpha=0.01, label='Resampled Fits' if i==0 else '')\n\n# Plot observed data\nax.scatter(x, y, label='Observed')\n\n# Plot true fit data\ny_true = theta * x\nax.plot(x, y_true, 'g', linewidth=2, label='True Model')\n\nax.set(\n title='Bootstrapped Slope Estimation',\n xlabel='x',\n ylabel='y'\n)\n\n# Change legend line alpha property\nhandles, labels = ax.get_legend_handles_labels()\nhandles[0].set_alpha(1)\n\nax.legend();", "_____no_output_____" ] ], [ [ "This looks pretty good! The bootstrapped estimates spread around the true model, as we would have hoped. Note that here we have the luxury to know the ground truth value for $\\theta$, but in applications we are trying to guess it from data. Therefore, assessing the quality of estimates based on finite data is a task of fundamental importance in data analysis.\n", "_____no_output_____" ], [ "---\n# Section 2: Confidence Intervals\n\nLet us now quantify how uncertain our estimated slope is. We do so by computing [confidence intervals](https://en.wikipedia.org/wiki/Confidence_interval) (CIs) from our bootstrapped estimates. The most direct approach is to compute percentiles from the empirical distribution of bootstrapped estimates. Note that this is widely applicable as we are not assuming that this empirical distribution is Gaussian.", "_____no_output_____" ] ], [ [ "#@title\n\n#@markdown Execute this cell to plot bootstrapped CI\n\ntheta_hats = bootstrap_estimates(x, y, n=2000)\nprint(f\"mean = {np.mean(theta_hats):.2f}, std = {np.std(theta_hats):.2f}\")\n\nfig, ax = plt.subplots()\nax.hist(theta_hats, bins=20, facecolor='C1', alpha=0.75)\nax.axvline(theta, c='g', label=r'True $\\theta$')\nax.axvline(np.percentile(theta_hats, 50), color='r', label='Median')\nax.axvline(np.percentile(theta_hats, 2.5), color='b', label='95% CI')\nax.axvline(np.percentile(theta_hats, 97.5), color='b')\nax.legend()\nax.set(\n title='Bootstrapped Confidence Interval',\n xlabel=r'$\\hat{{\\theta}}$',\n ylabel='count',\n xlim=[1.0, 1.5]\n);", "_____no_output_____" ] ], [ [ "Looking at the distribution of bootstrapped $\\hat{\\theta}$ values, we see that the true $\\theta$ falls well within the 95% confidence interval, wich is reinsuring. We also see that the value $\\theta = 1$ does not fall within the confidence interval. From this we would reject the hypothesis that the slope was 1.", "_____no_output_____" ], [ "---\n# Summary\n\n- Bootstrapping is a resampling procedure that allows to build confidence intervals around inferred parameter values\n- it is a widely applicable and very practical method that relies on computational power and pseudo-random number generators (as opposed to more classical approaches than depend on analytical derivations)", "_____no_output_____" ], [ "**Suggested readings** \n\nComputer Age Statistical Inference: Algorithms, Evidence and Data Science, by Bradley Efron and Trevor Hastie\n", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "## Dependencies", "_____no_output_____" ] ], [ [ "import warnings, math, json, glob\nimport pandas as pd\nimport tensorflow.keras.layers as L\nimport tensorflow.keras.backend as K\nfrom tensorflow.keras import Model\nfrom transformers import TFAutoModelForSequenceClassification, TFAutoModel, AutoTokenizer\nfrom commonlit_scripts import *\n\n\nseed = 0\nseed_everything(seed)\nwarnings.filterwarnings('ignore')\npd.set_option('display.max_colwidth', 150)", "_____no_output_____" ] ], [ [ "### Hardware configuration", "_____no_output_____" ] ], [ [ "strategy, tpu = get_strategy()\nAUTO = tf.data.AUTOTUNE\nREPLICAS = strategy.num_replicas_in_sync\nprint(f'REPLICAS: {REPLICAS}')", "REPLICAS: 1\n" ] ], [ [ "# Load data", "_____no_output_____" ] ], [ [ "base_path = '/kaggle/input/'\ntest_filepath = base_path + 'commonlitreadabilityprize/test.csv'\ntest = pd.read_csv(test_filepath)\nprint(f'Test samples: {len(test)}')\ndisplay(test.head())", "Test samples: 7\n" ] ], [ [ "# Model parameters", "_____no_output_____" ] ], [ [ "input_noteboks = [x for x in os.listdir(base_path) if '-commonlit-' in x]\ninput_base_path = f'{base_path}{input_noteboks[0]}/'\nwith open(input_base_path + 'config.json') as json_file:\n config = json.load(json_file)\n\nconfig", "_____no_output_____" ] ], [ [ "## Auxiliary functions", "_____no_output_____" ] ], [ [ "# Datasets utility functions\ndef custom_standardization(text, is_lower=True):\n if is_lower:\n text = text.lower() # if encoder is uncased\n text = text.strip()\n return text\n\ndef sample_target(features, target):\n mean, stddev = target\n sampled_target = tf.random.normal([], mean=tf.cast(mean, dtype=tf.float32), \n stddev=tf.cast(stddev, dtype=tf.float32), dtype=tf.float32)\n return (features, sampled_target)\n\ndef get_dataset(pandas_df, tokenizer, labeled=True, ordered=False, repeated=False, \n is_sampled=False, batch_size=32, seq_len=128, is_lower=True):\n \"\"\"\n Return a Tensorflow dataset ready for training or inference.\n \"\"\"\n text = [custom_standardization(text, is_lower) for text in pandas_df['excerpt']]\n \n # Tokenize inputs\n tokenized_inputs = tokenizer(text, max_length=seq_len, truncation=True, \n padding='max_length', return_tensors='tf')\n \n if labeled:\n dataset = tf.data.Dataset.from_tensor_slices(({'input_ids': tokenized_inputs['input_ids'], \n 'attention_mask': tokenized_inputs['attention_mask']}, \n (pandas_df['target'], pandas_df['standard_error'])))\n if is_sampled:\n dataset = dataset.map(sample_target, num_parallel_calls=tf.data.AUTOTUNE)\n else:\n dataset = tf.data.Dataset.from_tensor_slices({'input_ids': tokenized_inputs['input_ids'], \n 'attention_mask': tokenized_inputs['attention_mask']})\n \n if repeated:\n dataset = dataset.repeat()\n if not ordered:\n dataset = dataset.shuffle(2048)\n dataset = dataset.batch(batch_size)\n dataset = dataset.cache()\n dataset = dataset.prefetch(tf.data.AUTOTUNE)\n return dataset", "_____no_output_____" ], [ "model_path_list = glob.glob(f'{input_base_path}*.h5')\nmodel_path_list.sort()\n\nprint('Models to predict:')\nprint(*model_path_list, sep='\\n')", "Models to predict:\n/kaggle/input/39-commonlit-roberta-base-target-sampling-exp/model_0.h5\n" ] ], [ [ "# Model", "_____no_output_____" ] ], [ [ "def model_fn(encoder, seq_len=256):\n input_ids = L.Input(shape=(seq_len,), dtype=tf.int32, name='input_ids')\n input_attention_mask = L.Input(shape=(seq_len,), dtype=tf.int32, name='attention_mask')\n \n outputs = encoder({'input_ids': input_ids, \n 'attention_mask': input_attention_mask})\n last_hidden_state = outputs['last_hidden_state']\n \n cls_token = last_hidden_state[:, 0, :]\n \n output = L.Dense(1, name='output')(cls_token)\n \n model = Model(inputs=[input_ids, input_attention_mask], \n outputs=[output])\n return model\n\n\nwith strategy.scope():\n encoder = TFAutoModel.from_pretrained(config['BASE_MODEL'])\n # Freeze embeddings\n encoder.layers[0].embeddings.trainable = False\n model = model_fn(encoder, config['SEQ_LEN'])\n \nmodel.summary()", "Some layers from the model checkpoint at /kaggle/input/huggingface-roberta/roberta-base/ were not used when initializing TFRobertaModel: ['lm_head']\n- This IS expected if you are initializing TFRobertaModel from the checkpoint of a model trained on another task or with another architecture (e.g. initializing a BertForSequenceClassification model from a BertForPreTraining model).\n- This IS NOT expected if you are initializing TFRobertaModel from the checkpoint of a model that you expect to be exactly identical (initializing a BertForSequenceClassification model from a BertForSequenceClassification model).\nAll the layers of TFRobertaModel were initialized from the model checkpoint at /kaggle/input/huggingface-roberta/roberta-base/.\nIf your task is similar to the task the model of the checkpoint was trained on, you can already use TFRobertaModel for predictions without further training.\n" ] ], [ [ "# Test set predictions", "_____no_output_____" ] ], [ [ "tokenizer = AutoTokenizer.from_pretrained(config['BASE_MODEL'])\ntest_pred = []\n\nfor model_path in model_path_list:\n print(model_path)\n if tpu: tf.tpu.experimental.initialize_tpu_system(tpu)\n K.clear_session()\n model.load_weights(model_path)\n\n # Test predictions\n test_ds = get_dataset(test, tokenizer, labeled=False, ordered=True, \n batch_size=config['BATCH_SIZE'], seq_len=config['SEQ_LEN'])\n x_test = test_ds.map(lambda sample: sample)\n test_pred.append(model.predict(x_test))", "/kaggle/input/39-commonlit-roberta-base-target-sampling-exp/model_0.h5\n" ] ], [ [ "# Test set predictions", "_____no_output_____" ] ], [ [ "submission = test[['id']]\nsubmission['target'] = np.mean(test_pred, axis=0)\nsubmission.to_csv('submission.csv', index=False)\ndisplay(submission.head(10))", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "ADSL" ]

[ "ADSL" ]

[ "ADSL" ]

[ [ [ "from splinter import Browser\nfrom bs4 import BeautifulSoup\nimport time\nimport pandas as pd", "_____no_output_____" ], [ "# browser = Browser('chrome')", "_____no_output_____" ] ], [ [ "# NASA Mars News", "_____no_output_____" ] ], [ [ "mars={}", "_____no_output_____" ], [ "url = 'https://mars.nasa.gov/news/'\nbrowser.visit(url)\nhtml = browser.html\nsoup = BeautifulSoup(html,'html.parser')\nresultNasaMars = soup.findAll(\"div\",class_=\"content_title\")\nnasaTitle = resultNasaMars[1].a.text", "_____no_output_____" ], [ "result = soup.find(\"div\" ,class_=\"article_teaser_body\")\nnasaPara = result.text", "_____no_output_____" ], [ "mars[\"news_title\"] = nasaTitle \nmars[\"news_p\"] = nasaPara\nmars", "_____no_output_____" ] ], [ [ "## JPL Mars Space Images", "_____no_output_____" ] ], [ [ "url = 'https://www.jpl.nasa.gov/spaceimages/?search=&category=Mars'\nbrowser.visit(url)\nbrowser.find_by_id(\"full_image\").click()\nbrowser.find_link_by_partial_text(\"more info\").click()\nhtml = browser.html\nsoup = BeautifulSoup(html,'html.parser')\nresultJPLimage = soup.find(\"figure\",class_=\"lede\")\nresultJPLimage.a.img[\"src\"]", "_____no_output_____" ], [ "imgJPL = 'https://www.jpl.nasa.gov/' + resultJPLimage.a.img[\"src\"]\nmars['featured_image_url'] = imgJPL\nmars", "_____no_output_____" ] ], [ [ "## Mars Facts", "_____no_output_____" ] ], [ [ "mars_df = pd.read_html('https://space-facts.com/mars/')[0]\nmars_df.columns = [\"Description\",\"Value\"]\nmars_df.set_index(\"Description\", inplace = True)\nmars[\"facts\"] = mars_df.to_html()\nmars", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Load raw data", "_____no_output_____" ] ], [ [ "import numpy as np", "_____no_output_____" ], [ "data = np.loadtxt('SlowSteps1.csv', delimiter = ',') # load the raw data, change the filename as required!", "_____no_output_____" ] ], [ [ "# Find spikes", "_____no_output_____" ] ], [ [ "time_s = (data[:,8]-data[0,8])/1000000 # set the timing array to seconds and subtract 1st entry to zero it\nn_spikes = 0\nspike_times = [] # in seconds\nspike_points = [] # in timepoints\nfor x in range(1, data.shape[0]-1):\n if (data[x,0]>10 and data[x-1,0]<10): # looks for all instances where subsequent Vm points jump from <10 to >10\n spike_times.append(time_s[x])\n spike_points.append(x)\n n_spikes+=1\n \nprint(n_spikes, \"spikes detected\") \n", "168 spikes detected\n" ] ], [ [ "# Compute spike rate", "_____no_output_____" ] ], [ [ "spike_rate = np.zeros(data.shape[0])\n\nfor x in range(0, n_spikes-1):\n current_rate = 1/(spike_times[x+1]-spike_times[x])\n spike_rate[spike_points[x]:spike_points[x+1]]=current_rate\n", "_____no_output_____" ] ], [ [ "# Plot raw data and spike rate", "_____no_output_____" ] ], [ [ "from bokeh.plotting import figure, output_file, show\nfrom bokeh.layouts import column\nfrom bokeh.models import Range1d\n\noutput_file(\"RawDataPlot.html\")\n\nspike_plot = figure(plot_width=1200, plot_height = 100)\nspike_plot.line(time_s[:],spike_rate[:], line_width=1, line_color=\"black\") # Spike rate\nspike_plot.yaxis[0].axis_label = 'Rate (Hz)'\nspike_plot.xgrid.grid_line_color =None\nspike_plot.ygrid.grid_line_color =None\nspike_plot.xaxis.major_label_text_font_size = '0pt' # turn off x-axis tick labels\nspike_plot.yaxis.minor_tick_line_color = None # turn off y-axis minor ticks\n\nvm_plot = figure(plot_width=1200, plot_height = 300, y_range=Range1d(-100, 50),x_range=spike_plot.x_range)\nvm_plot.line(time_s[:],data[:,0], line_width=1, line_color=\"black\") # Vm\nvm_plot.scatter(spike_times[:],45, line_color=\"black\") # Rasterplot over spikes\nvm_plot.yaxis[0].axis_label = 'Vm (mV)'\nvm_plot.xgrid.grid_line_color =None\nvm_plot.ygrid.grid_line_color =None\nvm_plot.xaxis.major_label_text_font_size = '0pt' # turn off x-axis tick labels\n\nitotal_plot = figure(plot_width=1200, plot_height = 200, x_range=spike_plot.x_range)\nitotal_plot.line(time_s[:], data[:,1], line_width=1, line_color=\"black\") # Itotal\nitotal_plot.yaxis[0].axis_label = 'I total (a.u.)'\nitotal_plot.xgrid.grid_line_color =None\nitotal_plot.xaxis.major_label_text_font_size = '0pt' # turn off x-axis tick labels\n\nin_spikes_plot = figure(plot_width=1200, plot_height = 80, y_range=Range1d(-0.1,1.1), x_range=spike_plot.x_range)\nin_spikes_plot.line(time_s[:], data[:,3], line_width=1, line_color=\"black\") # Spikes in from Port 1\nin_spikes_plot.line(time_s[:], data[:,4], line_width=1, line_color=\"grey\") # Spikes in from Port 2\nin_spikes_plot.yaxis[0].axis_label = 'Input spikes'\nin_spikes_plot.xgrid.grid_line_color =None\nin_spikes_plot.ygrid.grid_line_color =None\nin_spikes_plot.yaxis.major_tick_line_color = None # turn off y-axis major ticks\nin_spikes_plot.yaxis.minor_tick_line_color = None # turn off y-axis minor ticks\nin_spikes_plot.xaxis.major_label_text_font_size = '0pt' # turn off x-axis tick labels\nin_spikes_plot.yaxis.major_label_text_font_size = '0pt' # turn off y-axis tick labels\n\nstim_plot = figure(plot_width=1200, plot_height = 100,y_range=Range1d(-0.1,1.1), x_range=spike_plot.x_range)\nstim_plot.line(time_s[:], data[:,2], line_width=1, line_color=\"black\") # Stimulus\nstim_plot.yaxis[0].axis_label = 'Stimulus'\nstim_plot.xaxis[0].axis_label = 'Time (s)'\nstim_plot.xgrid.grid_line_color =None\nstim_plot.ygrid.grid_line_color =None\nstim_plot.yaxis.major_tick_line_color = None # turn off y-axis major ticks\nstim_plot.yaxis.minor_tick_line_color = None # turn off y-axis minor ticks\nstim_plot.yaxis.major_label_text_font_size = '0pt' # turn off y-axis tick labels\n\nshow(column(spike_plot,vm_plot,itotal_plot,in_spikes_plot,stim_plot))\n", "WARNING:bokeh.core.validation.check:W-1004 (BOTH_CHILD_AND_ROOT): Models should not be a document root if they are in a layout box: Figure(id='25e4d8ca-bc35-44d5-9572-f71aea70c895', ...)\n" ] ], [ [ "# Analysis Option 1: Trigger stimuli and align", "_____no_output_____" ] ], [ [ "stimulus_times = []\nstimulus_times_s = []\nfor x in range(0, data.shape[0]-1): # goes through each timepoint\n if (data[x,2]<data[x+1,2]): # checks if the stimulus went from 0 to 1\n stimulus_times.append(x) ## make a list of times (in points) when stimulus increased \n stimulus_times_s.append(time_s[x]) ## also make a list of times (in seconds)\n \nloop_duration = stimulus_times[1]-stimulus_times[0] # compute arraylength for single stimulus\nloop_duration_s = stimulus_times_s[1]-stimulus_times_s[0] # compute arraylength for single stimulus also in s\n\nprint(loop_duration, \"points per loop;\", loop_duration_s, \"seconds\")\n\nsr_loops = []\nvm_loops = []\nitotal_loops = []\nstim_loops = []\n\nstimulus_times = np.where(data[:,2]>np.roll(data[:,2], axis = 0, shift = 1)) ## make a list of times when stimulus increased (again)\nsr_loops = np.vstack([spike_rate[x:x+loop_duration] for x in stimulus_times[0][:-1]])\nvm_loops = np.vstack([data[x:x+loop_duration, 0] for x in stimulus_times[0][:-1]])\nitotal_loops = np.vstack([data[x:x+loop_duration, 1] for x in stimulus_times[0][:-1]])\nstim_loops = np.vstack([data[x:x+loop_duration, 2] for x in stimulus_times[0][:-1]])\n\nst_loops = []\nfor i, x in enumerate(stimulus_times[0][:-1]):\n st_loops.append([time_s[sp]-time_s[x] for sp in spike_points if sp > x and sp < x+loop_duration])\n\nloops = vm_loops.shape[0]\nprint(loops, \"loops\") \n\n", "4000 points per loop; 7.27066 seconds\n8 loops\n" ] ], [ [ "# Make average arrays\n", "_____no_output_____" ] ], [ [ "sr_mean = np.mean(sr_loops, axis=0)\nvm_mean = np.mean(vm_loops, axis=0)\nitotal_mean = np.mean(itotal_loops, axis=0)\nstim_mean = np.mean(stim_loops, axis=0)", "_____no_output_____" ] ], [ [ "# Plot stimulus aligned data", "_____no_output_____" ] ], [ [ "from bokeh.plotting import figure, output_file, show\nfrom bokeh.layouts import column\nfrom bokeh.models import Range1d\n\noutput_file(\"AlignedDataPlot.html\")\n\nspike_plot = figure(plot_width=400, plot_height = 100)\nfor i in range(0,loops-1):\n spike_plot.line(time_s[0:loop_duration],sr_loops[i,:], line_width=1, line_color=\"gray\") # Vm individual repeats\nspike_plot.line(time_s[0:loop_duration],sr_mean[:], line_width=1.5, line_color=\"black\") # Vm mean\nspike_plot.yaxis[0].axis_label = 'Rate (Hz)'\nspike_plot.xgrid.grid_line_color =None\nspike_plot.ygrid.grid_line_color =None\nspike_plot.xaxis.major_label_text_font_size = '0pt' # turn off x-axis tick labels\n\n\ndot_plot = figure(plot_width=400, plot_height = 100, x_range=spike_plot.x_range)\nfor i in range(0,loops-1):\n dot_plot.scatter(st_loops[i],i, line_color=\"black\") # Rasterplot\ndot_plot.yaxis[0].axis_label = 'Repeat'\ndot_plot.xgrid.grid_line_color =None\ndot_plot.ygrid.grid_line_color =None\ndot_plot.xaxis.major_label_text_font_size = '0pt' # turn off x-axis tick labels\n\n\nvm_plot = figure(plot_width=400, plot_height = 300, y_range=Range1d(-100, 40),x_range=spike_plot.x_range)\nfor i in range(0,loops-1):\n vm_plot.line(time_s[0:loop_duration],vm_loops[i,:], line_width=1, line_color=\"gray\") # Vm individual repeats\nvm_plot.line(time_s[0:loop_duration],vm_mean[:], line_width=1.5, line_color=\"black\") # Vm mean\nvm_plot.yaxis[0].axis_label = 'Vm (mV)'\nvm_plot.xgrid.grid_line_color =None\nvm_plot.ygrid.grid_line_color =None\nvm_plot.xaxis.major_label_text_font_size = '0pt' # turn off x-axis tick labels\n\nitotal_plot = figure(plot_width=400, plot_height = 200, x_range=spike_plot.x_range)\nfor i in range(0,loops-1):\n itotal_plot.line(time_s[0:loop_duration], itotal_loops[i,:], line_width=1, line_color=\"gray\") # Itotal individual repeats\nitotal_plot.line(time_s[0:loop_duration], itotal_mean[:], line_width=1.5, line_color=\"black\") # Itotal mean\nitotal_plot.yaxis[0].axis_label = 'Itotal (a.u.)'\nitotal_plot.xgrid.grid_line_color =None\nitotal_plot.xaxis.major_label_text_font_size = '0pt' # turn off x-axis tick labels\n\nstim_plot = figure(plot_width=400, plot_height = 100,y_range=Range1d(-0.1,1.1), x_range=spike_plot.x_range)\nfor i in range(0,loops-1):\n stim_plot.line(time_s[0:loop_duration], stim_loops[i,:], line_width=1, line_color=\"gray\") # Stimulus individual repeats\nstim_plot.line(time_s[0:loop_duration], stim_mean[:], line_width=1.5, line_color=\"black\") # Stimulus mean \nstim_plot.yaxis[0].axis_label = 'Stimulus'\nstim_plot.xaxis[0].axis_label = 'Time (s)'\nstim_plot.xgrid.grid_line_color =None\nstim_plot.ygrid.grid_line_color =None\nstim_plot.yaxis.major_tick_line_color = None # turn off y-axis major ticks\nstim_plot.yaxis.minor_tick_line_color = None # turn off y-axis minor ticks\nstim_plot.yaxis.major_label_text_font_size = '0pt' # turn off y-axis tick labels\n\nshow(column(spike_plot,dot_plot,vm_plot,itotal_plot,stim_plot))", "WARNING:bokeh.core.validation.check:W-1004 (BOTH_CHILD_AND_ROOT): Models should not be a document root if they are in a layout box: Figure(id='25e4d8ca-bc35-44d5-9572-f71aea70c895', ...)\n" ] ], [ [ "# Analysis option 2: Spike triggered average (STA)", "_____no_output_____" ] ], [ [ "sta_points = 200 # number of points computed\n\nsta_individual = []\nsta_individual = np.vstack([data[x-sta_points:x,2] for x in spike_points[2:-1]])\nsta = np.mean(sta_individual, axis=0)\n\nimport matplotlib.pyplot as plt\nplt.plot(time_s[0:200],sta[:])\nplt.ylabel('Kernel amplitude')\nplt.xlabel('Time before spike (s)')\nplt.show()\n\n", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Convolutional Neural Networks: Step by Step\n\nWelcome to Course 4's first assignment! In this assignment, you will implement convolutional (CONV) and pooling (POOL) layers in numpy, including both forward propagation and (optionally) backward propagation. \n\nBy the end of this notebook, you'll be able to: \n\n* Explain the convolution operation\n* Apply two different types of pooling operation\n* Identify the components used in a convolutional neural network (padding, stride, filter, ...) and their purpose\n* Build a convolutional neural network \n\n**Notation**:\n- Superscript $[l]$ denotes an object of the $l^{th}$ layer. \n - Example: $a^{[4]}$ is the $4^{th}$ layer activation. $W^{[5]}$ and $b^{[5]}$ are the $5^{th}$ layer parameters.\n\n\n- Superscript $(i)$ denotes an object from the $i^{th}$ example. \n - Example: $x^{(i)}$ is the $i^{th}$ training example input.\n \n \n- Subscript $i$ denotes the $i^{th}$ entry of a vector.\n - Example: $a^{[l]}_i$ denotes the $i^{th}$ entry of the activations in layer $l$, assuming this is a fully connected (FC) layer.\n \n \n- $n_H$, $n_W$ and $n_C$ denote respectively the height, width and number of channels of a given layer. If you want to reference a specific layer $l$, you can also write $n_H^{[l]}$, $n_W^{[l]}$, $n_C^{[l]}$. \n- $n_{H_{prev}}$, $n_{W_{prev}}$ and $n_{C_{prev}}$ denote respectively the height, width and number of channels of the previous layer. If referencing a specific layer $l$, this could also be denoted $n_H^{[l-1]}$, $n_W^{[l-1]}$, $n_C^{[l-1]}$. \n\nYou should be familiar with `numpy` and/or have completed the previous courses of the specialization. Let's get started!", "_____no_output_____" ], [ "## Table of Contents\n\n- [1 - Packages](#1)\n- [2 - Outline of the Assignment](#2)\n- [3 - Convolutional Neural Networks](#3)\n - [3.1 - Zero-Padding](#3-1)\n - [Exercise 1 - zero_pad](#ex-1)\n - [3.2 - Single Step of Convolution](#3-2)\n - [Exercise 2 - conv_single_step](#ex-2)\n - [3.3 - Convolutional Neural Networks - Forward Pass](#3-3)\n - [Exercise 3 - conv_forward](#ex-3)\n- [4 - Pooling Layer](#4)\n - [4.1 - Forward Pooling](#4-1)\n - [Exercise 4 - pool_forward](#ex-4)\n- [5 - Backpropagation in Convolutional Neural Networks (OPTIONAL / UNGRADED)](#5)\n - [5.1 - Convolutional Layer Backward Pass](#5-1)\n - [5.1.1 - Computing dA](#5-1-1)\n - [5.1.2 - Computing dW](#5-1-2)\n - [5.1.3 - Computing db](#5-1-3)\n - [Exercise 5 - conv_backward](#ex-5)\n - [5.2 Pooling Layer - Backward Pass](#5-2)\n - [5.2.1 Max Pooling - Backward Pass](#5-2-1)\n - [Exercise 6 - create_mask_from_window](#ex-6)\n - [5.2.2 - Average Pooling - Backward Pass](#5-2-2)\n - [Exercise 7 - distribute_value](#ex-7)\n - [5.2.3 Putting it Together: Pooling Backward](#5-2-3)\n - [Exercise 8 - pool_backward](#ex-8)", "_____no_output_____" ], [ "<a name='1'></a>\n## 1 - Packages\n\nLet's first import all the packages that you will need during this assignment. \n- [numpy](www.numpy.org) is the fundamental package for scientific computing with Python.\n- [matplotlib](http://matplotlib.org) is a library to plot graphs in Python.\n- np.random.seed(1) is used to keep all the random function calls consistent. This helps to grade your work.", "_____no_output_____" ] ], [ [ "import numpy as np\nimport h5py\nimport matplotlib.pyplot as plt\nfrom public_tests import *\n\n%matplotlib inline\nplt.rcParams['figure.figsize'] = (5.0, 4.0) # set default size of plots\nplt.rcParams['image.interpolation'] = 'nearest'\nplt.rcParams['image.cmap'] = 'gray'\n\n%load_ext autoreload\n%autoreload 2\n\nnp.random.seed(1)", "_____no_output_____" ] ], [ [ "<a name='2'></a>\n## 2 - Outline of the Assignment\n\nYou will be implementing the building blocks of a convolutional neural network! Each function you will implement will have detailed instructions to walk you through the steps:\n\n- Convolution functions, including:\n - Zero Padding\n - Convolve window \n - Convolution forward\n - Convolution backward (optional)\n- Pooling functions, including:\n - Pooling forward\n - Create mask \n - Distribute value\n - Pooling backward (optional)\n \nThis notebook will ask you to implement these functions from scratch in `numpy`. In the next notebook, you will use the TensorFlow equivalents of these functions to build the following model:\n\n<img src=\"images/model.png\" style=\"width:800px;height:300px;\">\n\n**Note**: For every forward function, there is a corresponding backward equivalent. Hence, at every step of your forward module you will store some parameters in a cache. These parameters are used to compute gradients during backpropagation. ", "_____no_output_____" ], [ "<a name='3'></a>\n## 3 - Convolutional Neural Networks\n\nAlthough programming frameworks make convolutions easy to use, they remain one of the hardest concepts to understand in Deep Learning. A convolution layer transforms an input volume into an output volume of different size, as shown below. \n\n<img src=\"images/conv_nn.png\" style=\"width:350px;height:200px;\">\n\nIn this part, you will build every step of the convolution layer. You will first implement two helper functions: one for zero padding and the other for computing the convolution function itself. ", "_____no_output_____" ], [ "<a name='3-1'></a>\n### 3.1 - Zero-Padding\n\nZero-padding adds zeros around the border of an image:\n\n<img src=\"images/PAD.png\" style=\"width:600px;height:400px;\">\n<caption><center> <u> <font color='purple'> <b>Figure 1</b> </u><font color='purple'> : <b>Zero-Padding</b><br> Image (3 channels, RGB) with a padding of 2. </center></caption>\n\nThe main benefits of padding are:\n\n- It allows you to use a CONV layer without necessarily shrinking the height and width of the volumes. This is important for building deeper networks, since otherwise the height/width would shrink as you go to deeper layers. An important special case is the \"same\" convolution, in which the height/width is exactly preserved after one layer. \n\n- It helps us keep more of the information at the border of an image. Without padding, very few values at the next layer would be affected by pixels at the edges of an image.\n\n<a name='ex-1'></a>\n### Exercise 1 - zero_pad\nImplement the following function, which pads all the images of a batch of examples X with zeros. [Use np.pad](https://docs.scipy.org/doc/numpy/reference/generated/numpy.pad.html). Note if you want to pad the array \"a\" of shape $(5,5,5,5,5)$ with `pad = 1` for the 2nd dimension, `pad = 3` for the 4th dimension and `pad = 0` for the rest, you would do:\n```python\na = np.pad(a, ((0,0), (1,1), (0,0), (3,3), (0,0)), mode='constant', constant_values = (0,0))\n```", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: zero_pad\n\ndef zero_pad(X, pad):\n \"\"\"\n Pad with zeros all images of the dataset X. The padding is applied to the height and width of an image, \n as illustrated in Figure 1.\n \n Argument:\n X -- python numpy array of shape (m, n_H, n_W, n_C) representing a batch of m images\n pad -- integer, amount of padding around each image on vertical and horizontal dimensions\n \n Returns:\n X_pad -- padded image of shape (m, n_H + 2 * pad, n_W + 2 * pad, n_C)\n \"\"\"\n \n #(≈ 1 line)\n # X_pad = None\n # YOUR CODE STARTS HERE\n X_pad = np.pad(X, ((0, 0), (pad, pad), (pad, pad), (0, 0)), mode='constant', constant_values = 0)\n \n # YOUR CODE ENDS HERE\n \n return X_pad", "_____no_output_____" ], [ "np.random.seed(1)\nx = np.random.randn(4, 3, 3, 2)\nx_pad = zero_pad(x, 3)\nprint (\"x.shape =\\n\", x.shape)\nprint (\"x_pad.shape =\\n\", x_pad.shape)\nprint (\"x[1,1] =\\n\", x[1, 1])\nprint (\"x_pad[1,1] =\\n\", x_pad[1, 1])\n\nfig, axarr = plt.subplots(1, 2)\naxarr[0].set_title('x')\naxarr[0].imshow(x[0, :, :, 0])\naxarr[1].set_title('x_pad')\naxarr[1].imshow(x_pad[0, :, :, 0])\nzero_pad_test(zero_pad)", "x.shape =\n (4, 3, 3, 2)\nx_pad.shape =\n (4, 9, 9, 2)\nx[1,1] =\n [[ 0.90085595 -0.68372786]\n [-0.12289023 -0.93576943]\n [-0.26788808 0.53035547]]\nx_pad[1,1] =\n [[0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]]\nx.shape =\n (4, 3, 3, 2)\nx_pad.shape =\n (4, 9, 9, 2)\nx[1,1] =\n [[ 0.90085595 -0.68372786]\n [-0.12289023 -0.93576943]\n [-0.26788808 0.53035547]]\nx_pad[1,1] =\n [[0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]\n [0. 0.]]\n[[0. 0. 0. 0. 0. 0. 0. 0. 0.]\n [0. 0. 0. 0. 0. 0. 0. 0. 0.]]\n\u001b[92mAll tests passed!\n" ] ], [ [ "<a name='3-2'></a>\n### 3.2 - Single Step of Convolution \n\nIn this part, implement a single step of convolution, in which you apply the filter to a single position of the input. This will be used to build a convolutional unit, which: \n\n- Takes an input volume \n- Applies a filter at every position of the input\n- Outputs another volume (usually of different size)\n\n<img src=\"images/Convolution_schematic.gif\" style=\"width:500px;height:300px;\">\n<caption><center> <u> <font color='purple'> <b>Figure 2</b> </u><font color='purple'> : <b>Convolution operation</b><br> with a filter of 3x3 and a stride of 1 (stride = amount you move the window each time you slide) </center></caption>\n\nIn a computer vision application, each value in the matrix on the left corresponds to a single pixel value. You convolve a 3x3 filter with the image by multiplying its values element-wise with the original matrix, then summing them up and adding a bias. In this first step of the exercise, you will implement a single step of convolution, corresponding to applying a filter to just one of the positions to get a single real-valued output. \n\nLater in this notebook, you'll apply this function to multiple positions of the input to implement the full convolutional operation. \n\n<a name='ex-2'></a>\n### Exercise 2 - conv_single_step\nImplement `conv_single_step()`. \n \n[Hint](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.sum.html).", "_____no_output_____" ], [ "**Note**: The variable b will be passed in as a numpy array. If you add a scalar (a float or integer) to a numpy array, the result is a numpy array. In the special case of a numpy array containing a single value, you can cast it as a float to convert it to a scalar.", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: conv_single_step\n\ndef conv_single_step(a_slice_prev, W, b):\n \"\"\"\n Apply one filter defined by parameters W on a single slice (a_slice_prev) of the output activation \n of the previous layer.\n \n Arguments:\n a_slice_prev -- slice of input data of shape (f, f, n_C_prev)\n W -- Weight parameters contained in a window - matrix of shape (f, f, n_C_prev)\n b -- Bias parameters contained in a window - matrix of shape (1, 1, 1)\n \n Returns:\n Z -- a scalar value, the result of convolving the sliding window (W, b) on a slice x of the input data\n \"\"\"\n\n #(≈ 3 lines of code)\n # Element-wise product between a_slice_prev and W. Do not add the bias yet.\n # s = None\n # Sum over all entries of the volume s.\n # Z = None\n # Add bias b to Z. Cast b to a float() so that Z results in a scalar value.\n # Z = None\n # YOUR CODE STARTS HERE\n s = np.multiply(a_slice_prev, W)\n Z = np.sum(s)\n Z = Z + float(b)\n \n # YOUR CODE ENDS HERE\n\n return Z", "_____no_output_____" ], [ "np.random.seed(1)\na_slice_prev = np.random.randn(4, 4, 3)\nW = np.random.randn(4, 4, 3)\nb = np.random.randn(1, 1, 1)\n\nZ = conv_single_step(a_slice_prev, W, b)\nprint(\"Z =\", Z)\nconv_single_step_test(conv_single_step)\n\nassert (type(Z) == np.float64 or type(Z) == np.float32), \"You must cast the output to float\"\nassert np.isclose(Z, -6.999089450680221), \"Wrong value\"", "Z = -6.999089450680221\n\u001b[92mAll tests passed!\n" ] ], [ [ "<a name='3-3'></a>\n### 3.3 - Convolutional Neural Networks - Forward Pass\n\nIn the forward pass, you will take many filters and convolve them on the input. Each 'convolution' gives you a 2D matrix output. You will then stack these outputs to get a 3D volume: \n\n<center>\n<video width=\"620\" height=\"440\" src=\"images/conv_kiank.mp4\" type=\"video/mp4\" controls>\n</video>\n</center>\n\n<a name='ex-3'></a>\n### Exercise 3 - conv_forward\nImplement the function below to convolve the filters `W` on an input activation `A_prev`. \nThis function takes the following inputs:\n* `A_prev`, the activations output by the previous layer (for a batch of m inputs); \n* Weights are denoted by `W`. The filter window size is `f` by `f`.\n* The bias vector is `b`, where each filter has its own (single) bias. \n\nYou also have access to the hyperparameters dictionary, which contains the stride and the padding. \n\n**Hint**: \n1. To select a 2x2 slice at the upper left corner of a matrix \"a_prev\" (shape (5,5,3)), you would do:\n```python\na_slice_prev = a_prev[0:2,0:2,:]\n```\nNotice how this gives a 3D slice that has height 2, width 2, and depth 3. Depth is the number of channels. \nThis will be useful when you will define `a_slice_prev` below, using the `start/end` indexes you will define.\n\n2. To define a_slice you will need to first define its corners `vert_start`, `vert_end`, `horiz_start` and `horiz_end`. This figure may be helpful for you to find out how each of the corners can be defined using h, w, f and s in the code below.\n\n<img src=\"images/vert_horiz_kiank.png\" style=\"width:400px;height:300px;\">\n<caption><center> <u> <font color='purple'> <b>Figure 3</b> </u><font color='purple'> : <b>Definition of a slice using vertical and horizontal start/end (with a 2x2 filter)</b> <br> This figure shows only a single channel. </center></caption>\n\n\n**Reminder**:\n \nThe formulas relating the output shape of the convolution to the input shape are:\n \n$$n_H = \\Bigl\\lfloor \\frac{n_{H_{prev}} - f + 2 \\times pad}{stride} \\Bigr\\rfloor +1$$\n$$n_W = \\Bigl\\lfloor \\frac{n_{W_{prev}} - f + 2 \\times pad}{stride} \\Bigr\\rfloor +1$$\n$$n_C = \\text{number of filters used in the convolution}$$\n \n\n\n\nFor this exercise, don't worry about vectorization! Just implement everything with for-loops.", "_____no_output_____" ], [ "#### Additional Hints (if you're stuck):\n\n\n* Use array slicing (e.g.`varname[0:1,:,3:5]`) for the following variables: \n `a_prev_pad` ,`W`, `b` \n - Copy the starter code of the function and run it outside of the defined function, in separate cells. \n - Check that the subset of each array is the size and dimension that you're expecting. \n* To decide how to get the `vert_start`, `vert_end`, `horiz_start`, `horiz_end`, remember that these are indices of the previous layer. \n - Draw an example of a previous padded layer (8 x 8, for instance), and the current (output layer) (2 x 2, for instance). \n - The output layer's indices are denoted by `h` and `w`. \n* Make sure that `a_slice_prev` has a height, width and depth.\n* Remember that `a_prev_pad` is a subset of `A_prev_pad`. \n - Think about which one should be used within the for loops.", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: conv_forward\n\ndef conv_forward(A_prev, W, b, hparameters):\n \"\"\"\n Implements the forward propagation for a convolution function\n \n Arguments:\n A_prev -- output activations of the previous layer, \n numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)\n W -- Weights, numpy array of shape (f, f, n_C_prev, n_C)\n b -- Biases, numpy array of shape (1, 1, 1, n_C)\n hparameters -- python dictionary containing \"stride\" and \"pad\"\n \n Returns:\n Z -- conv output, numpy array of shape (m, n_H, n_W, n_C)\n cache -- cache of values needed for the conv_backward() function\n \"\"\"\n \n # Retrieve dimensions from A_prev's shape (≈1 line) \n # (m, n_H_prev, n_W_prev, n_C_prev) = None\n \n # Retrieve dimensions from W's shape (≈1 line)\n # (f, f, n_C_prev, n_C) = None\n \n # Retrieve information from \"hparameters\" (≈2 lines)\n # stride = None\n # pad = None\n \n # Compute the dimensions of the CONV output volume using the formula given above. \n # Hint: use int() to apply the 'floor' operation. (≈2 lines)\n # n_H = None\n # n_W = None\n \n # Initialize the output volume Z with zeros. (≈1 line)\n # Z = None\n \n # Create A_prev_pad by padding A_prev\n # A_prev_pad = None\n \n # for i in range(None): # loop over the batch of training examples\n # a_prev_pad = None # Select ith training example's padded activation\n # for h in range(None): # loop over vertical axis of the output volume\n # Find the vertical start and end of the current \"slice\" (≈2 lines)\n # vert_start = None\n # vert_end = None\n \n # for w in range(None): # loop over horizontal axis of the output volume\n # Find the horizontal start and end of the current \"slice\" (≈2 lines)\n # horiz_start = None\n # horiz_end = None\n \n # for c in range(None): # loop over channels (= #filters) of the output volume\n \n # Use the corners to define the (3D) slice of a_prev_pad (See Hint above the cell). (≈1 line)\n # a_slice_prev = None\n \n # Convolve the (3D) slice with the correct filter W and bias b, to get back one output neuron. (≈3 line)\n # weights = None\n # biases = None\n # Z[i, h, w, c] = None\n # YOUR CODE STARTS HERE\n (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape\n (f, f, n_C_prev, n_C) = W.shape\n stride = hparameters[\"stride\"]\n pad = hparameters[\"pad\"]\n n_H = int((n_H_prev - f + 2 * pad)/stride) + 1\n n_W = int((n_W_prev - f + 2 * pad)/stride) + 1\n Z = np.zeros((m, n_H, n_W, n_C))\n A_prev_pad = zero_pad(A_prev, pad)\n for i in range(m):\n a_prev_pad = A_prev_pad[i,:,:,:]\n for h in range(n_H):\n vert_start = h*stride\n vert_end = vert_start + f\n for w in range(n_W):\n horiz_start = w*stride\n horiz_end = horiz_start + f\n for c in range(n_C):\n a_slice_prev = a_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :]\n weights = W[:,:,:,c]\n biases = b[:,:,:,c]\n Z[i, h, w, c] = conv_single_step(a_slice_prev, weights, biases)\n \n # YOUR CODE ENDS HERE\n \n # Save information in \"cache\" for the backprop\n cache = (A_prev, W, b, hparameters)\n \n return Z, cache", "_____no_output_____" ], [ "np.random.seed(1)\nA_prev = np.random.randn(2, 5, 7, 4)\nW = np.random.randn(3, 3, 4, 8)\nb = np.random.randn(1, 1, 1, 8)\nhparameters = {\"pad\" : 1,\n \"stride\": 2}\n\nZ, cache_conv = conv_forward(A_prev, W, b, hparameters)\nprint(\"Z's mean =\\n\", np.mean(Z))\nprint(\"Z[0,2,1] =\\n\", Z[0, 2, 1])\nprint(\"cache_conv[0][1][2][3] =\\n\", cache_conv[0][1][2][3])\n\nconv_forward_test(conv_forward)\n", "Z's mean =\n 0.5511276474566768\nZ[0,2,1] =\n [-2.17796037 8.07171329 -0.5772704 3.36286738 4.48113645 -2.89198428\n 10.99288867 3.03171932]\ncache_conv[0][1][2][3] =\n [-1.1191154 1.9560789 -0.3264995 -1.34267579]\n\u001b[92mAll tests passed!\n" ] ], [ [ "Finally, a CONV layer should also contain an activation, in which case you would add the following line of code:\n\n```python\n# Convolve the window to get back one output neuron\nZ[i, h, w, c] = ...\n# Apply activation\nA[i, h, w, c] = activation(Z[i, h, w, c])\n```\n\nYou don't need to do it here, however. \n", "_____no_output_____" ], [ "<a name='4'></a>\n## 4 - Pooling Layer \n\nThe pooling (POOL) layer reduces the height and width of the input. It helps reduce computation, as well as helps make feature detectors more invariant to its position in the input. The two types of pooling layers are: \n\n- Max-pooling layer: slides an ($f, f$) window over the input and stores the max value of the window in the output.\n\n- Average-pooling layer: slides an ($f, f$) window over the input and stores the average value of the window in the output.\n\n<table>\n<td>\n<img src=\"images/max_pool1.png\" style=\"width:500px;height:300px;\">\n<td>\n\n<td>\n<img src=\"images/a_pool.png\" style=\"width:500px;height:300px;\">\n<td>\n</table>\n\nThese pooling layers have no parameters for backpropagation to train. However, they have hyperparameters such as the window size $f$. This specifies the height and width of the $f \\times f$ window you would compute a *max* or *average* over. \n\n<a name='4-1'></a>\n### 4.1 - Forward Pooling\nNow, you are going to implement MAX-POOL and AVG-POOL, in the same function. \n\n<a name='ex-4'></a>\n### Exercise 4 - pool_forward\n\nImplement the forward pass of the pooling layer. Follow the hints in the comments below.\n\n**Reminder**:\nAs there's no padding, the formulas binding the output shape of the pooling to the input shape is:\n\n$$n_H = \\Bigl\\lfloor \\frac{n_{H_{prev}} - f}{stride} \\Bigr\\rfloor +1$$\n\n$$n_W = \\Bigl\\lfloor \\frac{n_{W_{prev}} - f}{stride} \\Bigr\\rfloor +1$$\n\n$$n_C = n_{C_{prev}}$$\n\n\n", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: pool_forward\n\ndef pool_forward(A_prev, hparameters, mode = \"max\"):\n \"\"\"\n Implements the forward pass of the pooling layer\n \n Arguments:\n A_prev -- Input data, numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)\n hparameters -- python dictionary containing \"f\" and \"stride\"\n mode -- the pooling mode you would like to use, defined as a string (\"max\" or \"average\")\n \n Returns:\n A -- output of the pool layer, a numpy array of shape (m, n_H, n_W, n_C)\n cache -- cache used in the backward pass of the pooling layer, contains the input and hparameters \n \"\"\"\n \n # Retrieve dimensions from the input shape\n (m, n_H_prev, n_W_prev, n_C_prev) = A_prev.shape\n \n # Retrieve hyperparameters from \"hparameters\"\n f = hparameters[\"f\"]\n stride = hparameters[\"stride\"]\n \n # Define the dimensions of the output\n n_H = int(1 + (n_H_prev - f) / stride)\n n_W = int(1 + (n_W_prev - f) / stride)\n n_C = n_C_prev\n \n # Initialize output matrix A\n A = np.zeros((m, n_H, n_W, n_C)) \n \n # for i in range(None): # loop over the training examples\n # for h in range(None): # loop on the vertical axis of the output volume\n # Find the vertical start and end of the current \"slice\" (≈2 lines)\n # vert_start = None\n # vert_end = None\n \n # for w in range(None): # loop on the horizontal axis of the output volume\n # Find the vertical start and end of the current \"slice\" (≈2 lines)\n # horiz_start = None\n # horiz_end = None\n \n # for c in range (None): # loop over the channels of the output volume\n \n # Use the corners to define the current slice on the ith training example of A_prev, channel c. (≈1 line)\n # a_prev_slice = None\n \n # Compute the pooling operation on the slice. \n # Use an if statement to differentiate the modes. \n # Use np.max and np.mean.\n # if mode == \"max\":\n # A[i, h, w, c] = None\n # elif mode == \"average\":\n # A[i, h, w, c] = None\n \n # YOUR CODE STARTS HERE\n for i in range(m):\n for h in range(n_H):\n vert_start = h*stride\n vert_end = vert_start + f\n for w in range(n_W):\n horiz_start = w*stride\n horiz_end = horiz_start + f\n for c in range(n_C):\n a_prev_slice = A_prev[i, vert_start:vert_end, horiz_start:horiz_end, c]\n if mode == \"max\":\n A[i, h, w, c] = np.max(a_prev_slice)\n elif mode == \"average\":\n A[i, h, w, c] = np.mean(a_prev_slice)\n \n # YOUR CODE ENDS HERE\n \n # Store the input and hparameters in \"cache\" for pool_backward()\n cache = (A_prev, hparameters)\n \n # Making sure your output shape is correct\n #assert(A.shape == (m, n_H, n_W, n_C))\n \n return A, cache", "_____no_output_____" ], [ "# Case 1: stride of 1\nnp.random.seed(1)\nA_prev = np.random.randn(2, 5, 5, 3)\nhparameters = {\"stride\" : 1, \"f\": 3}\n\nA, cache = pool_forward(A_prev, hparameters, mode = \"max\")\nprint(\"mode = max\")\nprint(\"A.shape = \" + str(A.shape))\nprint(\"A[1, 1] =\\n\", A[1, 1])\nA, cache = pool_forward(A_prev, hparameters, mode = \"average\")\nprint(\"mode = average\")\nprint(\"A.shape = \" + str(A.shape))\nprint(\"A[1, 1] =\\n\", A[1, 1])\n\npool_forward_test(pool_forward)", "mode = max\nA.shape = (2, 3, 3, 3)\nA[1, 1] =\n [[1.96710175 0.84616065 1.27375593]\n [1.96710175 0.84616065 1.23616403]\n [1.62765075 1.12141771 1.2245077 ]]\nmode = average\nA.shape = (2, 3, 3, 3)\nA[1, 1] =\n [[ 0.44497696 -0.00261695 -0.31040307]\n [ 0.50811474 -0.23493734 -0.23961183]\n [ 0.11872677 0.17255229 -0.22112197]]\n\u001b[92mAll tests passed!\n" ] ], [ [ "**Expected output**\n\n```\nmode = max\nA.shape = (2, 3, 3, 3)\nA[1, 1] =\n [[1.96710175 0.84616065 1.27375593]\n [1.96710175 0.84616065 1.23616403]\n [1.62765075 1.12141771 1.2245077 ]]\n\nmode = average\nA.shape = (2, 3, 3, 3)\nA[1, 1] =\n [[ 0.44497696 -0.00261695 -0.31040307]\n [ 0.50811474 -0.23493734 -0.23961183]\n [ 0.11872677 0.17255229 -0.22112197]]\n```", "_____no_output_____" ] ], [ [ "# Case 2: stride of 2\nnp.random.seed(1)\nA_prev = np.random.randn(2, 5, 5, 3)\nhparameters = {\"stride\" : 2, \"f\": 3}\n\nA, cache = pool_forward(A_prev, hparameters)\nprint(\"mode = max\")\nprint(\"A.shape = \" + str(A.shape))\nprint(\"A[0] =\\n\", A[0])\nprint()\n\nA, cache = pool_forward(A_prev, hparameters, mode = \"average\")\nprint(\"mode = average\")\nprint(\"A.shape = \" + str(A.shape))\nprint(\"A[1] =\\n\", A[1])", "mode = max\nA.shape = (2, 2, 2, 3)\nA[0] =\n [[[1.74481176 0.90159072 1.65980218]\n [1.74481176 1.6924546 1.65980218]]\n\n [[1.13162939 1.51981682 2.18557541]\n [1.13162939 1.6924546 2.18557541]]]\n\nmode = average\nA.shape = (2, 2, 2, 3)\nA[1] =\n [[[-0.17313416 0.32377198 -0.34317572]\n [ 0.02030094 0.14141479 -0.01231585]]\n\n [[ 0.42944926 0.08446996 -0.27290905]\n [ 0.15077452 0.28911175 0.00123239]]]\n" ] ], [ [ "**Expected Output:**\n \n```\nmode = max\nA.shape = (2, 2, 2, 3)\nA[0] =\n [[[1.74481176 0.90159072 1.65980218]\n [1.74481176 1.6924546 1.65980218]]\n\n [[1.13162939 1.51981682 2.18557541]\n [1.13162939 1.6924546 2.18557541]]]\n\nmode = average\nA.shape = (2, 2, 2, 3)\nA[1] =\n [[[-0.17313416 0.32377198 -0.34317572]\n [ 0.02030094 0.14141479 -0.01231585]]\n\n [[ 0.42944926 0.08446996 -0.27290905]\n [ 0.15077452 0.28911175 0.00123239]]]\n```", "_____no_output_____" ], [ "<font color='blue'>\n \n**What you should remember**:\n\n* A convolution extracts features from an input image by taking the dot product between the input data and a 3D array of weights (the filter). \n* The 2D output of the convolution is called the feature map\n* A convolution layer is where the filter slides over the image and computes the dot product \n * This transforms the input volume into an output volume of different size \n* Zero padding helps keep more information at the image borders, and is helpful for building deeper networks, because you can build a CONV layer without shrinking the height and width of the volumes\n* Pooling layers gradually reduce the height and width of the input by sliding a 2D window over each specified region, then summarizing the features in that region", "_____no_output_____" ], [ "**Congratulations**! You have now implemented the forward passes of all the layers of a convolutional network. Great work!\n\nThe remainder of this notebook is optional, and will not be graded. If you carry on, just remember to hit the Submit button to submit your work for grading first. ", "_____no_output_____" ], [ "<a name='5'></a>\n## 5 - Backpropagation in Convolutional Neural Networks (OPTIONAL / UNGRADED)\n\nIn modern deep learning frameworks, you only have to implement the forward pass, and the framework takes care of the backward pass, so most deep learning engineers don't need to bother with the details of the backward pass. The backward pass for convolutional networks is complicated. If you wish, you can work through this optional portion of the notebook to get a sense of what backprop in a convolutional network looks like. \n\nWhen in an earlier course you implemented a simple (fully connected) neural network, you used backpropagation to compute the derivatives with respect to the cost to update the parameters. Similarly, in convolutional neural networks you can calculate the derivatives with respect to the cost in order to update the parameters. The backprop equations are not trivial and were not derived in lecture, but are briefly presented below.\n\n<a name='5-1'></a>\n### 5.1 - Convolutional Layer Backward Pass \n\nLet's start by implementing the backward pass for a CONV layer. \n\n<a name='5-1-1'></a>\n#### 5.1.1 - Computing dA:\nThis is the formula for computing $dA$ with respect to the cost for a certain filter $W_c$ and a given training example:\n\n$$dA \\mathrel{+}= \\sum _{h=0} ^{n_H} \\sum_{w=0} ^{n_W} W_c \\times dZ_{hw} \\tag{1}$$\n\nWhere $W_c$ is a filter and $dZ_{hw}$ is a scalar corresponding to the gradient of the cost with respect to the output of the conv layer Z at the hth row and wth column (corresponding to the dot product taken at the ith stride left and jth stride down). Note that at each time, you multiply the the same filter $W_c$ by a different dZ when updating dA. We do so mainly because when computing the forward propagation, each filter is dotted and summed by a different a_slice. Therefore when computing the backprop for dA, you are just adding the gradients of all the a_slices. \n\nIn code, inside the appropriate for-loops, this formula translates into:\n```python\nda_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :] += W[:,:,:,c] * dZ[i, h, w, c]\n```\n\n<a name='5-1-2'></a>\n#### 5.1.2 - Computing dW:\nThis is the formula for computing $dW_c$ ($dW_c$ is the derivative of one filter) with respect to the loss:\n\n$$dW_c \\mathrel{+}= \\sum _{h=0} ^{n_H} \\sum_{w=0} ^ {n_W} a_{slice} \\times dZ_{hw} \\tag{2}$$\n\nWhere $a_{slice}$ corresponds to the slice which was used to generate the activation $Z_{ij}$. Hence, this ends up giving us the gradient for $W$ with respect to that slice. Since it is the same $W$, we will just add up all such gradients to get $dW$. \n\nIn code, inside the appropriate for-loops, this formula translates into:\n```python\ndW[:,:,:,c] \\mathrel{+}= a_slice * dZ[i, h, w, c]\n```\n\n<a name='5-1-3'></a>\n#### 5.1.3 - Computing db:\n\nThis is the formula for computing $db$ with respect to the cost for a certain filter $W_c$:\n\n$$db = \\sum_h \\sum_w dZ_{hw} \\tag{3}$$\n\nAs you have previously seen in basic neural networks, db is computed by summing $dZ$. In this case, you are just summing over all the gradients of the conv output (Z) with respect to the cost. \n\nIn code, inside the appropriate for-loops, this formula translates into:\n```python\ndb[:,:,:,c] += dZ[i, h, w, c]\n```\n\n<a name='ex-5'></a>\n### Exercise 5 - conv_backward\n\nImplement the `conv_backward` function below. You should sum over all the training examples, filters, heights, and widths. You should then compute the derivatives using formulas 1, 2 and 3 above. ", "_____no_output_____" ] ], [ [ "def conv_backward(dZ, cache):\n \"\"\"\n Implement the backward propagation for a convolution function\n \n Arguments:\n dZ -- gradient of the cost with respect to the output of the conv layer (Z), numpy array of shape (m, n_H, n_W, n_C)\n cache -- cache of values needed for the conv_backward(), output of conv_forward()\n \n Returns:\n dA_prev -- gradient of the cost with respect to the input of the conv layer (A_prev),\n numpy array of shape (m, n_H_prev, n_W_prev, n_C_prev)\n dW -- gradient of the cost with respect to the weights of the conv layer (W)\n numpy array of shape (f, f, n_C_prev, n_C)\n db -- gradient of the cost with respect to the biases of the conv layer (b)\n numpy array of shape (1, 1, 1, n_C)\n \"\"\" \n \n \n # Retrieve information from \"cache\"\n # (A_prev, W, b, hparameters) = None\n # Retrieve dimensions from A_prev's shape\n # (m, n_H_prev, n_W_prev, n_C_prev) = None\n # Retrieve dimensions from W's shape\n # (f, f, n_C_prev, n_C) = None\n \n # Retrieve information from \"hparameters\"\n # stride = None\n # pad = None\n \n # Retrieve dimensions from dZ's shape\n # (m, n_H, n_W, n_C) = None\n \n # Initialize dA_prev, dW, db with the correct shapes\n # dA_prev = None \n # dW = None\n # db = None\n \n # Pad A_prev and dA_prev\n # A_prev_pad = zero_pad(A_prev, pad)\n # dA_prev_pad = zero_pad(dA_prev, pad)\n \n #for i in range(m): # loop over the training examples\n \n # select ith training example from A_prev_pad and dA_prev_pad\n # a_prev_pad = None\n # da_prev_pad = None\n \n #for h in range(n_H): # loop over vertical axis of the output volume\n # for w in range(n_W): # loop over horizontal axis of the output volume\n # for c in range(n_C): # loop over the channels of the output volume\n \n # Find the corners of the current \"slice\"\n # vert_start = None\n # vert_end = None\n # horiz_start = None\n # horiz_end = None\n\n # Use the corners to define the slice from a_prev_pad\n # a_slice = None\n\n # Update gradients for the window and the filter's parameters using the code formulas given above\n # da_prev_pad[vert_start:vert_end, horiz_start:horiz_end, :] += None\n # dW[:,:,:,c] += None\n # db[:,:,:,c] += None\n \n # Set the ith training example's dA_prev to the unpadded da_prev_pad (Hint: use X[pad:-pad, pad:-pad, :])\n # dA_prev[i, :, :, :] = None\n # YOUR CODE STARTS HERE\n \n \n # YOUR CODE ENDS HERE\n \n # Making sure your output shape is correct\n assert(dA_prev.shape == (m, n_H_prev, n_W_prev, n_C_prev))\n \n return dA_prev, dW, db", "_____no_output_____" ], [ "# We'll run conv_forward to initialize the 'Z' and 'cache_conv\",\n# which we'll use to test the conv_backward function\nnp.random.seed(1)\nA_prev = np.random.randn(10, 4, 4, 3)\nW = np.random.randn(2, 2, 3, 8)\nb = np.random.randn(1, 1, 1, 8)\nhparameters = {\"pad\" : 2,\n \"stride\": 2}\nZ, cache_conv = conv_forward(A_prev, W, b, hparameters)\n\n# Test conv_backward\ndA, dW, db = conv_backward(Z, cache_conv)\n\nprint(\"dA_mean =\", np.mean(dA))\nprint(\"dW_mean =\", np.mean(dW))\nprint(\"db_mean =\", np.mean(db))\n\nassert type(dA) == np.ndarray, \"Output must be a np.ndarray\"\nassert type(dW) == np.ndarray, \"Output must be a np.ndarray\"\nassert type(db) == np.ndarray, \"Output must be a np.ndarray\"\nassert dA.shape == (10, 4, 4, 3), f\"Wrong shape for dA {dA.shape} != (10, 4, 4, 3)\"\nassert dW.shape == (2, 2, 3, 8), f\"Wrong shape for dW {dW.shape} != (2, 2, 3, 8)\"\nassert db.shape == (1, 1, 1, 8), f\"Wrong shape for db {db.shape} != (1, 1, 1, 8)\"\nassert np.isclose(np.mean(dA), 1.4524377), \"Wrong values for dA\"\nassert np.isclose(np.mean(dW), 1.7269914), \"Wrong values for dW\"\nassert np.isclose(np.mean(db), 7.8392325), \"Wrong values for db\"\n\nprint(\"\\033[92m All tests passed.\")", "_____no_output_____" ] ], [ [ "**Expected Output**:\n<table>\n <tr>\n <td>\n dA_mean\n </td>\n <td>\n 1.45243777754\n </td>\n </tr>\n <tr>\n <td>\n dW_mean\n </td>\n <td>\n 1.72699145831\n </td>\n </tr>\n <tr>\n <td>\n db_mean\n </td>\n <td>\n 7.83923256462\n </td>\n </tr>\n\n</table>\n", "_____no_output_____" ], [ "<a name='5-2'></a>\n## 5.2 Pooling Layer - Backward Pass\n\nNext, let's implement the backward pass for the pooling layer, starting with the MAX-POOL layer. Even though a pooling layer has no parameters for backprop to update, you still need to backpropagate the gradient through the pooling layer in order to compute gradients for layers that came before the pooling layer. \n\n<a name='5-2-1'></a>\n### 5.2.1 Max Pooling - Backward Pass \n\nBefore jumping into the backpropagation of the pooling layer, you are going to build a helper function called `create_mask_from_window()` which does the following: \n\n$$ X = \\begin{bmatrix}\n1 && 3 \\\\\n4 && 2\n\\end{bmatrix} \\quad \\rightarrow \\quad M =\\begin{bmatrix}\n0 && 0 \\\\\n1 && 0\n\\end{bmatrix}\\tag{4}$$\n\nAs you can see, this function creates a \"mask\" matrix which keeps track of where the maximum of the matrix is. True (1) indicates the position of the maximum in X, the other entries are False (0). You'll see later that the backward pass for average pooling is similar to this, but uses a different mask. \n\n<a name='ex-6'></a>\n### Exercise 6 - create_mask_from_window\n\nImplement `create_mask_from_window()`. This function will be helpful for pooling backward. \nHints:\n- [np.max()]() may be helpful. It computes the maximum of an array.\n- If you have a matrix X and a scalar x: `A = (X == x)` will return a matrix A of the same size as X such that:\n```\nA[i,j] = True if X[i,j] = x\nA[i,j] = False if X[i,j] != x\n```\n- Here, you don't need to consider cases where there are several maxima in a matrix.", "_____no_output_____" ] ], [ [ "def create_mask_from_window(x):\n \"\"\"\n Creates a mask from an input matrix x, to identify the max entry of x.\n \n Arguments:\n x -- Array of shape (f, f)\n \n Returns:\n mask -- Array of the same shape as window, contains a True at the position corresponding to the max entry of x.\n \"\"\" \n # (≈1 line)\n # mask = None\n # YOUR CODE STARTS HERE\n \n \n # YOUR CODE ENDS HERE\n return mask", "_____no_output_____" ], [ "np.random.seed(1)\nx = np.random.randn(2, 3)\nmask = create_mask_from_window(x)\nprint('x = ', x)\nprint(\"mask = \", mask)\n\nx = np.array([[-1, 2, 3],\n [2, -3, 2],\n [1, 5, -2]])\n\ny = np.array([[False, False, False],\n [False, False, False],\n [False, True, False]])\nmask = create_mask_from_window(x)\n\nassert type(mask) == np.ndarray, \"Output must be a np.ndarray\"\nassert mask.shape == x.shape, \"Input and output shapes must match\"\nassert np.allclose(mask, y), \"Wrong output. The True value must be at position (2, 1)\"\n\nprint(\"\\033[92m All tests passed.\")", "_____no_output_____" ] ], [ [ "**Expected Output:** \n\n<table> \n<tr> \n<td>\n\n**x =**\n</td>\n\n<td>\n\n[[ 1.62434536 -0.61175641 -0.52817175] <br>\n [-1.07296862 0.86540763 -2.3015387 ]]\n\n </td>\n</tr>\n\n<tr> \n<td>\nmask =\n</td>\n<td>\n[[ True False False] <br>\n [False False False]]\n</td>\n</tr>\n\n\n</table>", "_____no_output_____" ], [ "Why keep track of the position of the max? It's because this is the input value that ultimately influenced the output, and therefore the cost. Backprop is computing gradients with respect to the cost, so anything that influences the ultimate cost should have a non-zero gradient. So, backprop will \"propagate\" the gradient back to this particular input value that had influenced the cost. ", "_____no_output_____" ], [ "<a name='5-2-2'></a>\n### 5.2.2 - Average Pooling - Backward Pass \n\nIn max pooling, for each input window, all the \"influence\" on the output came from a single input value--the max. In average pooling, every element of the input window has equal influence on the output. So to implement backprop, you will now implement a helper function that reflects this.\n\nFor example if we did average pooling in the forward pass using a 2x2 filter, then the mask you'll use for the backward pass will look like: \n$$ dZ = 1 \\quad \\rightarrow \\quad dZ =\\begin{bmatrix}\n1/4 && 1/4 \\\\\n1/4 && 1/4\n\\end{bmatrix}\\tag{5}$$\n\nThis implies that each position in the $dZ$ matrix contributes equally to output because in the forward pass, we took an average. \n\n<a name='ex-7'></a>\n### Exercise 7 - distribute_value\n\nImplement the function below to equally distribute a value dz through a matrix of dimension shape. \n\n[Hint](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.ones.html)", "_____no_output_____" ] ], [ [ "def distribute_value(dz, shape):\n \"\"\"\n Distributes the input value in the matrix of dimension shape\n \n Arguments:\n dz -- input scalar\n shape -- the shape (n_H, n_W) of the output matrix for which we want to distribute the value of dz\n \n Returns:\n a -- Array of size (n_H, n_W) for which we distributed the value of dz\n \"\"\" \n # Retrieve dimensions from shape (≈1 line)\n # (n_H, n_W) = None\n \n # Compute the value to distribute on the matrix (≈1 line)\n # average = None\n \n # Create a matrix where every entry is the \"average\" value (≈1 line)\n # a = None\n # YOUR CODE STARTS HERE\n \n \n # YOUR CODE ENDS HERE\n return a", "_____no_output_____" ], [ "a = distribute_value(2, (2, 2))\nprint('distributed value =', a)\n\n\nassert type(a) == np.ndarray, \"Output must be a np.ndarray\"\nassert a.shape == (2, 2), f\"Wrong shape {a.shape} != (2, 2)\"\nassert np.sum(a) == 2, \"Values must sum to 2\"\n\na = distribute_value(100, (10, 10))\nassert type(a) == np.ndarray, \"Output must be a np.ndarray\"\nassert a.shape == (10, 10), f\"Wrong shape {a.shape} != (10, 10)\"\nassert np.sum(a) == 100, \"Values must sum to 100\"\n\nprint(\"\\033[92m All tests passed.\")", "_____no_output_____" ] ], [ [ "**Expected Output**: \n\n<table> \n<tr> \n<td>\ndistributed_value =\n</td>\n<td>\n[[ 0.5 0.5]\n<br\\> \n[ 0.5 0.5]]\n</td>\n</tr>\n</table>", "_____no_output_____" ], [ "<a name='5-2-3'></a>\n### 5.2.3 Putting it Together: Pooling Backward \n\nYou now have everything you need to compute backward propagation on a pooling layer.\n\n<a name='ex-8'></a>\n### Exercise 8 - pool_backward\n\nImplement the `pool_backward` function in both modes (`\"max\"` and `\"average\"`). You will once again use 4 for-loops (iterating over training examples, height, width, and channels). You should use an `if/elif` statement to see if the mode is equal to `'max'` or `'average'`. If it is equal to 'average' you should use the `distribute_value()` function you implemented above to create a matrix of the same shape as `a_slice`. Otherwise, the mode is equal to '`max`', and you will create a mask with `create_mask_from_window()` and multiply it by the corresponding value of dA.", "_____no_output_____" ] ], [ [ "def pool_backward(dA, cache, mode = \"max\"):\n \"\"\"\n Implements the backward pass of the pooling layer\n \n Arguments:\n dA -- gradient of cost with respect to the output of the pooling layer, same shape as A\n cache -- cache output from the forward pass of the pooling layer, contains the layer's input and hparameters \n mode -- the pooling mode you would like to use, defined as a string (\"max\" or \"average\")\n \n Returns:\n dA_prev -- gradient of cost with respect to the input of the pooling layer, same shape as A_prev\n \"\"\"\n # Retrieve information from cache (≈1 line)\n # (A_prev, hparameters) = None\n \n # Retrieve hyperparameters from \"hparameters\" (≈2 lines)\n # stride = None\n # f = None\n \n # Retrieve dimensions from A_prev's shape and dA's shape (≈2 lines)\n # m, n_H_prev, n_W_prev, n_C_prev = None\n # m, n_H, n_W, n_C = None\n \n # Initialize dA_prev with zeros (≈1 line)\n # dA_prev = None\n \n # for i in range(None): # loop over the training examples\n \n # select training example from A_prev (≈1 line)\n # a_prev = None\n \n # for h in range(n_H): # loop on the vertical axis\n # for w in range(n_W): # loop on the horizontal axis\n # for c in range(n_C): # loop over the channels (depth)\n \n # Find the corners of the current \"slice\" (≈4 lines)\n # vert_start = None\n # vert_end = None\n # horiz_start = None\n # horiz_end = None\n \n # Compute the backward propagation in both modes.\n # if mode == \"max\":\n \n # Use the corners and \"c\" to define the current slice from a_prev (≈1 line)\n # a_prev_slice = None\n \n # Create the mask from a_prev_slice (≈1 line)\n # mask = None\n\n # Set dA_prev to be dA_prev + (the mask multiplied by the correct entry of dA) (≈1 line)\n # dA_prev[i, vert_start: vert_end, horiz_start: horiz_end, c] += None\n \n # elif mode == \"average\":\n \n # Get the value da from dA (≈1 line)\n # da = None\n \n # Define the shape of the filter as fxf (≈1 line)\n # shape = None\n\n # Distribute it to get the correct slice of dA_prev. i.e. Add the distributed value of da. (≈1 line)\n # dA_prev[i, vert_start: vert_end, horiz_start: horiz_end, c] += None\n # YOUR CODE STARTS HERE\n \n \n # YOUR CODE ENDS HERE\n \n # Making sure your output shape is correct\n assert(dA_prev.shape == A_prev.shape)\n \n return dA_prev", "_____no_output_____" ], [ "np.random.seed(1)\nA_prev = np.random.randn(5, 5, 3, 2)\nhparameters = {\"stride\" : 1, \"f\": 2}\nA, cache = pool_forward(A_prev, hparameters)\nprint(A.shape)\nprint(cache[0].shape)\ndA = np.random.randn(5, 4, 2, 2)\n\ndA_prev1 = pool_backward(dA, cache, mode = \"max\")\nprint(\"mode = max\")\nprint('mean of dA = ', np.mean(dA))\nprint('dA_prev1[1,1] = ', dA_prev1[1, 1]) \nprint()\ndA_prev2 = pool_backward(dA, cache, mode = \"average\")\nprint(\"mode = average\")\nprint('mean of dA = ', np.mean(dA))\nprint('dA_prev2[1,1] = ', dA_prev2[1, 1]) \n\nassert type(dA_prev1) == np.ndarray, \"Wrong type\"\nassert dA_prev1.shape == (5, 5, 3, 2), f\"Wrong shape {dA_prev1.shape} != (5, 5, 3, 2)\"\nassert np.allclose(dA_prev1[1, 1], [[0, 0], \n [ 5.05844394, -1.68282702],\n [ 0, 0]]), \"Wrong values for mode max\"\nassert np.allclose(dA_prev2[1, 1], [[0.08485462, 0.2787552], \n [1.26461098, -0.25749373], \n [1.17975636, -0.53624893]]), \"Wrong values for mode average\"\nprint(\"\\033[92m All tests passed.\")", "_____no_output_____" ] ], [ [ "**Expected Output**: \n\nmode = max:\n<table> \n<tr> \n<td>\n\n**mean of dA =**\n</td>\n\n<td>\n\n0.145713902729\n\n </td>\n</tr>\n\n<tr> \n<td>\ndA_prev[1,1] =\n</td>\n<td>\n[[ 0. 0. ] <br>\n [ 5.05844394 -1.68282702] <br>\n [ 0. 0. ]]\n</td>\n</tr>\n</table>\n\nmode = average\n<table> \n<tr> \n<td>\n\nmean of dA =\n</td>\n\n<td>\n\n0.145713902729\n\n </td>\n</tr>\n\n<tr> \n<td>\ndA_prev[1,1] =\n</td>\n<td>\n[[ 0.08485462 0.2787552 ] <br>\n [ 1.26461098 -0.25749373] <br>\n [ 1.17975636 -0.53624893]]\n</td>\n</tr>\n</table>", "_____no_output_____" ], [ "**Congratulations**! You've completed the assignment and its optional portion. You now understand how convolutional neural networks work, and have implemented all the building blocks of a neural network. In the next assignment you will implement a ConvNet using TensorFlow. Nicely done! See you there.", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "## Regression with BIWI head pose dataset", "_____no_output_____" ], [ "This is a more advanced example to show how to create custom datasets and do regression with images. Our task is to find the center of the head in each image. The data comes from the [BIWI head pose dataset](https://data.vision.ee.ethz.ch/cvl/gfanelli/head_pose/head_forest.html#db), thanks to Gabriele Fanelli et al. We have converted the images to jpeg format, so you should download the converted dataset from [this link](https://s3.amazonaws.com/fast-ai-imagelocal/biwi_head_pose.tgz).", "_____no_output_____" ] ], [ [ "%reload_ext autoreload\n%autoreload 2\n%matplotlib inline", "_____no_output_____" ], [ "from fastai import *\nfrom fastai.vision import *", "_____no_output_____" ] ], [ [ "## Getting and converting the data", "_____no_output_____" ] ], [ [ "path = untar_data(URLs.BIWI_HEAD_POSE)", "_____no_output_____" ], [ "cal = np.genfromtxt(path/'01'/'rgb.cal', skip_footer=6); cal", "_____no_output_____" ], [ "fname = '09/frame_00667_rgb.jpg'", "_____no_output_____" ], [ "def img2txt_name(f): return path/f'{str(f)[:-7]}pose.txt'", "_____no_output_____" ], [ "img = open_image(path/fname)\nimg.show()", "_____no_output_____" ], [ "ctr = np.genfromtxt(img2txt_name(fname), skip_header=3); ctr", "_____no_output_____" ], [ "def convert_biwi(coords):\n c1 = coords[0] * cal[0][0]/coords[2] + cal[0][2]\n c2 = coords[1] * cal[1][1]/coords[2] + cal[1][2]\n return tensor([c2,c1])\n\ndef get_ctr(f):\n ctr = np.genfromtxt(img2txt_name(f), skip_header=3)\n return convert_biwi(ctr)\n\ndef get_ip(img,pts): return ImagePoints(FlowField(img.size, pts), scale=True)", "_____no_output_____" ], [ "get_ctr(fname)", "_____no_output_____" ], [ "ctr = get_ctr(fname)\nimg.show(y=get_ip(img, ctr), figsize=(6, 6))", "_____no_output_____" ] ], [ [ "## Creating a dataset", "_____no_output_____" ] ], [ [ "data = (ImageItemList.from_folder(path)\n .split_by_valid_func(lambda o: o.parent.name=='13')\n .label_from_func(get_ctr, label_cls=PointsItemList)\n .transform(get_transforms(), tfm_y=True, size=(120,160))\n .databunch().normalize(imagenet_stats)\n )", "_____no_output_____" ], [ "data.show_batch(3, figsize=(9,6))", "_____no_output_____" ] ], [ [ "## Train model", "_____no_output_____" ] ], [ [ "learn = create_cnn(data, models.resnet34)", "_____no_output_____" ], [ "learn.lr_find()\nlearn.recorder.plot()", "LR Finder is complete, type {learner_name}.recorder.plot() to see the graph.\n" ], [ "lr = 2e-2", "_____no_output_____" ], [ "learn.fit_one_cycle(5, slice(lr))", "Total time: 07:28\nepoch train_loss valid_loss\n1 0.043327 0.010848 (01:34)\n2 0.015479 0.001792 (01:27)\n3 0.006021 0.001171 (01:28)\n4 0.003105 0.000521 (01:27)\n5 0.002425 0.000381 (01:29)\n\n" ], [ "learn.save('stage-1')", "_____no_output_____" ], [ "learn.load('stage-1');", "_____no_output_____" ], [ "learn.show_results()", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Choosing the number of segments - Elbow chart method", "_____no_output_____" ], [ "This document illustrates how to decide the number of segments (optimal $k$) using elbow charts.", "_____no_output_____" ], [ "## Introducing elbow chart method", "_____no_output_____" ], [ "**When we should (not) add more clusters**: Ideally, the lower the $SSE$ is, the better is the clustering. Although adding more clusters (a higher $k$) always reduces $SSE$, adding too many clusters can be managerially cumbersome (e.g., when designing individual strategies for each segment) and redundant (e.g., nearby clusters have little differences). Hence, we want to add more clusters if doing so can **significantly** reduce $SSE$, and stop adding clusters if doing so **doesn't reduce $SSE$ by much**.", "_____no_output_____" ], [ "**How elbow chart works**: The elbow chart plots a curve of how SSE changes with the number of clusters. Because adding more clusters will reduce SSE, the curve will be downward sloping, and the curve is steeper if adding one more cluster ($k \\rightarrow k+1$) reduces SSE by a greater amount. We should choose the cluster number $k$ that corresponds to the \"elbow point\" in the plot (the kink where the curve exhibits an \"L\" shape). The elbow point indicates that the curve is steeper on the left ($SSE$ decreases a lot from $k-1$ to $k$), and is flatter on the right ($SSE$ decreases not much from $k$ to $k+1$).", "_____no_output_____" ], [ "**Procedure**: Suppose we want to create no more than $K$ segments. The procedure is as follows:\n1. For $k$ from $1$ to $K$: run k-mean algorithm with $k$ clusters, and calculate and record the $SSE$.\n2. Plot $SSE$ over the number of segments $k$ to get the elbow chart.\n3. Find $k$ that corresponds to the elbow point. This is the optimal number of segments to segment consumers.\n4. Use the optimal $k$ to run k-mean algorithm to segment consumers.", "_____no_output_____" ], [ "We will use \"MallCustomersTwoVariables.csv\" for analysis.", "_____no_output_____" ], [ "## Loading data and preprocessing ", "_____no_output_____" ], [ "This section will generate the normalized dataframe, `df_normalized`, for k-mean algorithm.", "_____no_output_____" ] ], [ [ "# importing packages\nimport numpy as np\nimport pandas as pd\nfrom sklearn.cluster import KMeans # Use \"sklearn/cluster/KMeans\" for clustering analysis \n\n# importing data and renaming variables\nurl = \"https://raw.githubusercontent.com/zoutianxin1992/MarketingAnalyticsPython/main/Marketing%20Analytics%20in%20Python/Segmentation/Datasets/MallCustomersTwoVariables.csv\"\ndf = pd.read_csv(url,index_col=0) # use the first column (customer id) as index\ndf = df.rename(columns = {\"Annual Income (k$)\":\"annual_income\",\"Spending Score (1-100)\":\"spending_score\"})\n\n\n# normalizing the data for k-mean algorithm\ndf_normalized = (df-df.min())/(df.max()-df.min()) # By default, pandas calculate maximums and minimums by columns, which serves our purpose.", "_____no_output_____" ] ], [ [ "## Calculate $SSE$ for each $k$", "_____no_output_____" ], [ "For exposition, we will create no more than $K = 10$ clusters, and calculate $SSE$s when $k = 1,2,3,...,K$. This can be achieved with a for loop.\n<br />\n(If you use Windows, you may see a warning of \"KMeans is known to have a memory leak....\" Don't worry in our case because both our data size and the number of clusters are much smaller than when the problem will happen.)", "_____no_output_____" ] ], [ [ "K = 10 # K is the maximum number of clusters we will check\nstore_SSE = np.zeros(K) # create a vector to store SSE's. The k-th entry will be the SSE with k clusters.\n\nfor k in range(1, K+1): # try k from 1 to K \n kmeanSpec = KMeans(n_clusters = k, n_init = 100) # set up k-mean model with k clusters\n kmean_result = kmeanSpec.fit(df_normalized) # run k-mean on normalized data\n store_SSE[k-1] = kmeanSpec.inertia_ # store the SSE (.inertia_) in the k-th entry of store_SSE\n", "C:\\Users\\zoutianxin\\AppData\\Local\\Continuum\\anaconda3\\lib\\site-packages\\sklearn\\cluster\\_kmeans.py:882: UserWarning: KMeans is known to have a memory leak on Windows with MKL, when there are less chunks than available threads. You can avoid it by setting the environment variable OMP_NUM_THREADS=1.\n f\"KMeans is known to have a memory leak on Windows \"\n" ] ], [ [ "## Generate elbow chart", "_____no_output_____" ] ], [ [ "from matplotlib import pyplot as plt\n%matplotlib inline\nplt.rcParams['figure.figsize'] = [12,8] # set figure size to be 12*8 inch\nplt.plot(range(1, K+1), store_SSE) \nplt.xticks(range(1, K+1), fontsize = 18)\nplt.yticks(fontsize = 18)\nplt.ylabel(\"SSE\",fontsize = 18)\nplt.xlabel(\"number of clusters\", fontsize = 18)\n", "_____no_output_____" ] ], [ [ "As we can see, the elbow point (kink of \"L\" shape) appears at $k = 5$, which will be the optimal number of segments to use. ", "_____no_output_____" ], [ "## Potential Problems of the elbow-chart method", "_____no_output_____" ], [ "- There may be no apparent elbow points or multiple elbow points in the chart\n- Choice of elbow points is rather subjective", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# DIMAML for Autoencoder models\n\nTraining is on Celeba. Evaluation is on Tiny ImageNet", "_____no_output_____" ] ], [ [ "%load_ext autoreload\n%autoreload 2\n%env CUDA_VISIBLE_DEVICES=0\nimport os, sys, time\nsys.path.insert(0, '..')\nimport lib\n\nimport math\nimport numpy as np\nfrom copy import deepcopy\nimport torch, torch.nn as nn\nimport torch.nn.functional as F\nimport matplotlib.pyplot as plt\n%matplotlib inline\nplt.style.use('seaborn-darkgrid')\nplt.rcParams['pdf.fonttype'] = 42\nplt.rcParams['ps.fonttype'] = 42\n\n# For reproducibility\nimport random\nseed = random.randint(0, 2 ** 32 - 1)\nrandom.seed(seed)\nnp.random.seed(seed)\ntorch.manual_seed(seed)\ntorch.backends.cudnn.deterministic = True\ntorch.backends.cudnn.benchmark = False\n\nprint(seed)", "_____no_output_____" ] ], [ [ "## Setting", "_____no_output_____" ] ], [ [ "model_type = 'AE'\n\n# Dataset \ndata_dir = './data'\ntrain_batch_size = 128\nvalid_batch_size = 256\ntest_batch_size = 128\nnum_workers = 3\npin_memory = True\n\ndevice = 'cuda' if torch.cuda.is_available() else 'cpu'\n\n# AE\nlatent_dim = 64 \nloss_function = F.mse_loss\n\n# MAML\nmax_steps = 1500\ninner_loop_steps_in_epoch = 200\ninner_loop_epochs = 3\ninner_loop_steps = inner_loop_steps_in_epoch * inner_loop_epochs\nmeta_grad_clip = 10.\n\nloss_kwargs={'reduction':'mean'}\nloss_interval = 50\nfirst_val_step = 200\n\nassert (inner_loop_steps - first_val_step) % loss_interval == 0\nvalidation_steps = int((inner_loop_steps - first_val_step) / loss_interval + 1)\n\n# Inner optimizer\ninner_optimizer_type='momentum'\ninner_optimizer_kwargs = dict(\n lr=0.01, momentum=0.9, \n nesterov=False, weight_decay=0.0\n)\n\n# Meta optimizer\nmeta_learning_rate = 1e-4\nmeta_betas = (0.9, 0.997)\nmeta_decay_interval = max_steps\n\ncheckpoint_steps = 15\nrecovery_step = None\n\nkwargs = dict(\n first_valid_step=first_val_step,\n valid_loss_interval=loss_interval, \n loss_kwargs=loss_kwargs, \n)", "_____no_output_____" ], [ "exp_name = f\"{model_type}{latent_dim}_celeba_{inner_optimizer_type}\" + \\\n f\"_steps{inner_loop_steps}_interval{loss_interval}\" + \\\n f\"_tr_bs{train_batch_size}_val_bs{valid_batch_size}_seed_{seed}\"\n \nprint(\"Experiment name: \", exp_name)\n\nlogs_path = \"./logs/{}\".format(exp_name)\nassert recovery_step is not None or not os.path.exists(logs_path)\n# !rm -rf {logs_path}", "_____no_output_____" ] ], [ [ "## Prepare the CelebA dataset", "_____no_output_____" ] ], [ [ "import pandas as pd\nimport shutil\n\nceleba_data_dir = 'data/celeba/'\ndata = pd.read_csv(os.path.join(celeba_data_dir, 'list_eval_partition.csv'))\n\ntry:\n for partition in ['train', 'val', 'test']:\n os.makedirs(os.path.join(celeba_data_dir, partition))\n os.makedirs(os.path.join(celeba_data_dir, partition, 'images'))\n\n for i in data.index:\n partition = data.loc[i].partition\n src_path = os.path.join(celeba_data_dir, 'img_align_celeba/img_align_celeba', data.loc[i].image_id)\n if partition == 0:\n shutil.copyfile(src_path, os.path.join(celeba_data_dir, 'train', 'images', data.loc[i].image_id))\n elif partition == 1:\n shutil.copyfile(src_path, os.path.join(celeba_data_dir, 'val', 'images', data.loc[i].image_id))\n elif partition == 2:\n shutil.copyfile(src_path, os.path.join(celeba_data_dir, 'test', 'images', data.loc[i].image_id))\n \nexcept FileExistsError:\n print('\\'train\\', \\'val\\', \\'test\\' already exist. Probably, you do not want to copy data again')", "_____no_output_____" ], [ "from torchvision import transforms, datasets\nfrom torch.utils.data import DataLoader\n\nceleba_transforms = transforms.Compose([\n transforms.Resize((64, 64)),\n transforms.ToTensor(),\n])\n\n# Create the train set\nceleba_train_dataset = datasets.ImageFolder(celeba_data_dir+'train', transform=celeba_transforms)\nceleba_train_images = torch.cat([celeba_train_dataset[i][0][None] for i in range(len(celeba_train_dataset))])\n\nceleba_mean_image = celeba_train_images.mean(0)\nceleba_std_image = celeba_train_images.std(0)\nceleba_train_images = (celeba_train_images - celeba_mean_image) / celeba_std_image\n\n# Create the val set\nceleba_valid_dataset = datasets.ImageFolder(celeba_data_dir+'val', celeba_transforms)\nceleba_valid_images = torch.cat([celeba_valid_dataset[i][0][None] for i in range(len(celeba_valid_dataset))])\nceleba_valid_images = (celeba_valid_images - celeba_mean_image) / celeba_std_image\n\n# Create the test set\nceleba_test_dataset = datasets.ImageFolder(celeba_data_dir+'test', celeba_transforms)\nceleba_test_images = torch.cat([celeba_test_dataset[i][0][None] for i in range(len(celeba_test_dataset))])\nceleba_test_images = (celeba_test_images - celeba_mean_image) / celeba_std_image\n\n# Create data loaders \ntrain_loader = torch.utils.data.DataLoader(celeba_train_images, batch_size=train_batch_size, shuffle=True,\n pin_memory=pin_memory, num_workers=num_workers)\nvalid_loader = torch.utils.data.DataLoader(celeba_valid_images, batch_size=valid_batch_size, shuffle=True,\n pin_memory=pin_memory, num_workers=num_workers)\ntest_loader = torch.utils.data.DataLoader(celeba_test_images, batch_size=test_batch_size, \n pin_memory=pin_memory, num_workers=num_workers)", "_____no_output_____" ] ], [ [ "## Create the model and meta-optimizer", "_____no_output_____" ] ], [ [ "optimizer = lib.make_inner_optimizer(inner_optimizer_type, **inner_optimizer_kwargs)\nmodel = lib.models.AE(latent_dim)\nmaml = lib.MAML(model, model_type, optimizer=optimizer, \n checkpoint_steps=checkpoint_steps,\n loss_function=loss_function\n).to(device)", "_____no_output_____" ] ], [ [ "## Trainer", "_____no_output_____" ] ], [ [ "def samples_batches(dataloader, num_batches):\n x_batches = []\n for batch_i, x_batch in enumerate(dataloader):\n if batch_i >= num_batches: break\n x_batches.append(x_batch)\n return x_batches\n\n\nclass TrainerAE(lib.Trainer):\n def train_on_batch(self, train_loader, valid_loader, prefix='train/', **kwargs):\n \"\"\" Performs a single gradient update and reports metrics \"\"\"\n # Sample train and val batches\n x_batches = []\n for _ in range(inner_loop_epochs):\n x_batches.extend(samples_batches(train_loader, inner_loop_steps_in_epoch))\n x_val_batches = samples_batches(valid_loader, validation_steps)\n\n # Perform a meta training step\n self.meta_optimizer.zero_grad()\n with lib.training_mode(self.maml, is_train=True):\n self.maml.resample_parameters()\n _updated_model, train_loss_history, valid_loss_history, *etc = \\\n self.maml.forward(x_batches, x_batches, x_val_batches, x_val_batches, \n device=self.device, **kwargs) \n train_loss = torch.cat(train_loss_history).mean()\n valid_loss = torch.cat(valid_loss_history).mean() if len(valid_loss_history) > 0 else torch.zeros(1)\n valid_loss.backward()\n\n # Check gradients \n grad_norm = lib.utils.total_norm_frobenius(self.maml.initializers.parameters())\n self.writer.add_scalar(prefix + \"grad_norm\", grad_norm, self.total_steps)\n bad_grad = not math.isfinite(grad_norm)\n\n if not bad_grad:\n nn.utils.clip_grad_norm_(list(self.maml.initializers.parameters()), meta_grad_clip)\n else:\n print(\"Fix bad grad. Loss {} | Grad {}\".format(train_loss.item(), grad_norm))\n for param in self.maml.initializers.parameters():\n param.grad = torch.where(torch.isfinite(param.grad), \n param.grad, torch.zeros_like(param.grad))\n self.meta_optimizer.step()\n return self.record(train_loss=train_loss.item(),\n valid_loss=valid_loss.item(), prefix=prefix)\n \n def evaluate_metrics(self, train_loader, test_loader, prefix='val/', **kwargs):\n \"\"\" Predicts and evaluates metrics over the entire dataset \"\"\"\n torch.cuda.empty_cache()\n \n print('Baseline')\n self.maml.resample_parameters(initializers=self.maml.untrained_initializers, is_final=True)\n base_model = deepcopy(self.maml.model) \n base_train_loss_history, base_test_loss_history = eval_model(base_model, train_loader, test_loader,\n device=self.device, **kwargs)\n print('DIMAML')\n self.maml.resample_parameters(is_final=True)\n maml_model = deepcopy(self.maml.model)\n maml_train_loss_history, maml_test_loss_history = eval_model(maml_model, train_loader, test_loader, \n device=self.device, **kwargs)\n lib.utils.ae_draw_plots(base_train_loss_history, base_test_loss_history, \n maml_train_loss_history, maml_test_loss_history)\n \n self.writer.add_scalar(prefix + \"train_AUC\", sum(maml_train_loss_history), self.total_steps)\n self.writer.add_scalar(prefix + \"test_AUC\", sum(maml_test_loss_history), self.total_steps)\n self.writer.add_scalar(prefix + \"test_loss\", maml_test_loss_history[-1], self.total_steps)", "_____no_output_____" ], [ "########################\n# Generate Train Batch #\n########################\n \ndef generate_train_batches(train_loader, batches_in_epoch=150):\n x_batches = []\n for batch_i, x_batch in enumerate(train_loader):\n if batch_i >= batches_in_epoch: break\n x_batches.append(x_batch)\n\n assert len(x_batches) == batches_in_epoch\n local_x = torch.cat(x_batches, dim=0)\n return DataLoader(local_x, batch_size=train_batch_size, shuffle=True, \n num_workers=num_workers, pin_memory=pin_memory)\n\n##################\n# Eval functions #\n##################\n\[email protected]_grad()\ndef compute_test_loss(model, loss_function, test_loader, device='cuda'):\n model.eval() \n test_loss = 0.\n for batch_test in test_loader:\n if isinstance(batch_test, (list, tuple)):\n x_test = batch_test[0].to(device)\n elif isinstance(batch_test, torch.Tensor):\n x_test = batch_test.to(device)\n else:\n raise Exception(\"Wrong batch\")\n preds = model(x_test)\n test_loss += loss_function(preds, x_test) * x_test.shape[0]\n test_loss /= len(test_loader.dataset)\n model.train()\n return test_loss.item()\n\n\ndef eval_model(model, train_loader, test_loader, batches_in_epoch=150, \n epochs=3, test_loss_interval=50, device='cuda', **kwargs):\n optimizer = lib.optimizers.make_eval_inner_optimizer(\n maml, model, inner_optimizer_type, \n **inner_optimizer_kwargs\n )\n train_loss_history = []\n test_loss_history = []\n \n training_mode = model.training\n total_iters = 0\n for epoch in range(1, epochs + 1):\n model.train()\n for x_batch in train_loader:\n optimizer.zero_grad()\n x_batch = x_batch.to(device)\n preds = model(x_batch)\n loss = loss_function(preds, x_batch)\n loss.backward()\n optimizer.step()\n train_loss_history.append(loss.item())\n \n if (total_iters == 0) or (total_iters + 1) % test_loss_interval == 0: \n model.eval()\n test_loss = compute_test_loss(model, loss_function, test_loader, device=device)\n print(\"Epoch {} | Total Iteration {} | Loss {}\".format(epoch, total_iters+1, test_loss))\n test_loss_history.append(test_loss)\n model.train()\n \n total_iters += 1 \n model.train(training_mode)\n return train_loss_history, test_loss_history", "_____no_output_____" ], [ "train_loss_history = []\nvalid_loss_history = []\n\ntrainer = TrainerAE(maml, meta_lr=meta_learning_rate, \n meta_betas=meta_betas, meta_grad_clip=meta_grad_clip,\n exp_name=exp_name, recovery_step=recovery_step)", "_____no_output_____" ], [ "from IPython.display import clear_output\n\nlib.free_memory()\nt0 = time.time()\n\nwhile trainer.total_steps <= max_steps:\n local_train_loader = generate_train_batches(train_loader, inner_loop_steps_in_epoch)\n \n with lib.activate_context_batchnorm(maml.model):\n metrics = trainer.train_on_batch(\n local_train_loader, valid_loader, **kwargs\n )\n train_loss = metrics['train_loss']\n train_loss_history.append(train_loss)\n \n valid_loss = metrics['valid_loss']\n valid_loss_history.append(valid_loss)\n\n if trainer.total_steps % 20 == 0:\n clear_output(True)\n print(\"Step: %d | Time: %f | Train Loss %.5f | Valid loss %.5f\" \n % (trainer.total_steps, time.time()-t0, train_loss, valid_loss))\n plt.figure(figsize=[16, 5])\n plt.subplot(1,2,1)\n plt.title('Train Loss over time')\n plt.plot(lib.utils.moving_average(train_loss_history, span=50))\n plt.scatter(range(len(train_loss_history)), train_loss_history, alpha=0.1)\n plt.subplot(1,2,2)\n plt.title('Valid Loss over time')\n plt.plot(lib.utils.moving_average(valid_loss_history, span=50))\n plt.scatter(range(len(valid_loss_history)), valid_loss_history, alpha=0.1)\n plt.show()\n trainer.evaluate_metrics(local_train_loader, test_loader, epochs=inner_loop_epochs,\n test_loss_interval=loss_interval)\n lib.utils.ae_visualize_pdf(maml)\n t0 = time.time()\n \n if trainer.total_steps % 100 == 0:\n trainer.save_model()\n \n trainer.total_steps += 1", "_____no_output_____" ] ], [ [ "## Probability Functions ", "_____no_output_____" ] ], [ [ "lib.utils.ae_visualize_pdf(maml)", "_____no_output_____" ] ], [ [ "# Evaluation", "_____no_output_____" ] ], [ [ "torch.backends.cudnn.deterministic = False\ntorch.backends.cudnn.benchmark = True", "_____no_output_____" ], [ "def genOrthgonal(dim):\n a = torch.zeros((dim, dim)).normal_(0, 1)\n q, r = torch.qr(a)\n d = torch.diag(r, 0).sign()\n diag_size = d.size(0)\n d_exp = d.view(1, diag_size).expand(diag_size, diag_size)\n q.mul_(d_exp)\n return q\n\ndef makeDeltaOrthogonal(weights, gain):\n rows = weights.size(0)\n cols = weights.size(1)\n if rows < cols:\n print(\"In_filters should not be greater than out_filters.\")\n weights.data.fill_(0)\n dim = max(rows, cols)\n q = genOrthgonal(dim)\n mid1 = weights.size(2) // 2\n mid2 = weights.size(3) // 2\n with torch.no_grad():\n weights[:, :, mid1, mid2] = q[:weights.size(0), :weights.size(1)]\n weights.mul_(gain)", "_____no_output_____" ], [ "def gradient_quotient(loss, params, eps=1e-5): \n grad = torch.autograd.grad(loss, params, retain_graph=True, create_graph=True)\n prod = torch.autograd.grad(sum([(g**2).sum() / 2 for g in grad]),\n params, retain_graph=True, create_graph=True)\n out = sum([((g - p) / (g + eps * (2*(g >= 0).float() - 1).detach()) - 1).abs().sum() \n for g, p in zip(grad, prod)])\n return out / sum([p.data.nelement() for p in params])\n\n\ndef metainit(model, criterion, x_size, lr=0.1, momentum=0.9, steps=200, eps=1e-5):\n model.eval()\n params = [p for p in model.parameters() \n if p.requires_grad and len(p.size()) >= 2]\n memory = [0] * len(params)\n for i in range(steps):\n input = torch.Tensor(*x_size).normal_(0, 1).cuda()\n loss = criterion(model(input), input)\n gq = gradient_quotient(loss, list(model.parameters()), eps)\n \n grad = torch.autograd.grad(gq, params)\n for j, (p, g_all) in enumerate(zip(params, grad)):\n norm = p.data.norm().item()\n g = torch.sign((p.data * g_all).sum() / norm) \n memory[j] = momentum * memory[j] - lr * g.item() \n new_norm = norm + memory[j]\n p.data.mul_(new_norm / (norm + eps))\n print(\"%d/GQ = %.2f\" % (i, gq.item()))", "_____no_output_____" ] ], [ [ "## Evalution on Tiny Imagenet", "_____no_output_____" ] ], [ [ "class PixelNormalize(object):\n def __init__(self, mean_image, std_image):\n self.mean_image = mean_image\n self.std_image = std_image\n \n def __call__(self, image):\n normalized_image = (image - self.mean_image) / self.std_image\n return normalized_image\n\n \nclass Flip(object):\n def __call__(self, image):\n if random.random() > 0.5:\n return image.flip(-1)\n else:\n return image\n \n \nclass CustomTensorDataset(torch.utils.data.Dataset):\n \"\"\" TensorDataset with support of transforms \"\"\"\n def __init__(self, *tensors, transform=None):\n assert all(tensors[0].size(0) == tensor.size(0) for tensor in tensors)\n self.tensors = tensors\n self.transform = transform\n \n def __getitem__(self, index):\n x = self.tensors[0][index]\n \n if self.transform:\n x = self.transform(x)\n return x\n \n def __len__(self):\n return self.tensors[0].size(0)", "_____no_output_____" ], [ "# Load train and valid data\nfrom torchvision import transforms, datasets\nfrom torch.utils.data import DataLoader\n\ndata_dir = 'data/tiny-imagenet-200/'\n\ntrain_image_dataset = datasets.ImageFolder(os.path.join(data_dir, 'train'), transforms.ToTensor())\ntrain_images = torch.cat([train_image_dataset[i][0][None] for i in range(len(train_image_dataset))], dim=0)\nmean_image = train_images.mean(0)\nstd_image = train_images.std(0)\n\ntrain_transforms = transforms.Compose([\n Flip(),\n PixelNormalize(mean_image, std_image),\n])\n\neval_transforms = transforms.Compose([\n PixelNormalize(mean_image, std_image),\n])\n\nti_train_dataset = CustomTensorDataset(train_images, transform=train_transforms)\n\n\nvalid_image_dataset = datasets.ImageFolder(os.path.join(data_dir, 'val'), transforms.ToTensor())\nvalid_images = torch.cat([valid_image_dataset[i][0][None] for i in range(len(valid_image_dataset))], dim=0)\nti_valid_dataset = CustomTensorDataset(valid_images, transform=eval_transforms)\n\ntest_image_dataset = datasets.ImageFolder(os.path.join(data_dir, 'test'), transforms.ToTensor())\ntest_images = torch.cat([test_image_dataset[i][0][None] for i in range(len(test_image_dataset))], dim=0)\nti_test_dataset = CustomTensorDataset(test_images, transform=eval_transforms)\n\n\n# Create data loaders\nti_train_loader = DataLoader(\n ti_train_dataset, batch_size=train_batch_size, shuffle=True,\n num_workers=num_workers, pin_memory=pin_memory,\n)\n\nti_valid_loader = DataLoader(\n ti_valid_dataset, batch_size=valid_batch_size, shuffle=True,\n num_workers=num_workers, pin_memory=pin_memory,\n)\n\nti_test_loader = DataLoader(\n ti_test_dataset, batch_size=test_batch_size, shuffle=False, \n num_workers=num_workers, pin_memory=pin_memory\n)", "_____no_output_____" ], [ "num_reruns = 10\nti_batches_in_epoch = len(ti_train_loader) #782 - full epoch\nassert ti_batches_in_epoch == 782\n\nti_base_runs_10 = []\nti_base_runs_50 = []\nti_base_runs_100 = []\n\nti_metainit_runs_10 = []\nti_metainit_runs_50 = []\nti_metainit_runs_100 = []\n\nti_deltaorthogonal_runs_10 = []\nti_deltaorthogonal_runs_50 = []\nti_deltaorthogonal_runs_100 = []\n\nti_maml_runs_10 = []\nti_maml_runs_50 = []\nti_maml_runs_100 = []\n\nfor _ in range(num_reruns):\n print(\"Baseline\")\n maml.resample_parameters(initializers=maml.untrained_initializers, is_final=True)\n base_model = deepcopy(maml.model) \n base_train_loss_history, base_test_loss_history = \\\n eval_model(base_model, ti_train_loader, ti_test_loader, epochs=100, \n test_loss_interval=10*ti_batches_in_epoch, device=device)\n \n print(\"MetaInit\")\n batch_x = next(iter(ti_train_loader))\n maml.resample_parameters(initializers=maml.untrained_initializers, is_final=True)\n metainit_model = deepcopy(maml.model)\n metainit(metainit_model, loss_function, batch_x.shape, steps=200)\n \n metainit_train_loss_history, metainit_test_loss_history = \\\n eval_model(metainit_model, ti_train_loader, ti_test_loader, \n batches_in_epoch=ti_batches_in_epoch, epochs=100, \n test_loss_interval=10*ti_batches_in_epoch, device=device)\n \n print(\"Delta Orthogonal\")\n maml.resample_parameters(initializers=maml.untrained_initializers, is_final=True)\n deltaorthogonal_model = deepcopy(maml.model)\n for param in deltaorthogonal_model.parameters():\n if len(param.size()) >= 4:\n makeDeltaOrthogonal(param, nn.init.calculate_gain('relu'))\n \n deltaorthogonal_train_loss_history, deltaorthogonal_test_loss_history = \\\n eval_model(deltaorthogonal_model, ti_train_loader, ti_test_loader, \n batches_in_epoch=ti_batches_in_epoch, epochs=100, \n test_loss_interval=10*ti_batches_in_epoch, device=device)\n \n ti_deltaorthogonal_runs_10.append(deltaorthogonal_test_loss_history[1])\n ti_deltaorthogonal_runs_50.append(deltaorthogonal_test_loss_history[5])\n ti_deltaorthogonal_runs_100.append(deltaorthogonal_test_loss_history[10])\n\n print(\"DIMAML\")\n maml.resample_parameters(is_final=True)\n maml_model = deepcopy(maml.model)\n maml_train_loss_history, maml_test_loss_history = \\\n eval_model(maml_model, ti_train_loader, ti_test_loader, epochs=100, \n test_loss_interval=10*ti_batches_in_epoch, device=device)\n \n ti_base_runs_10.append(base_test_loss_history[1])\n ti_base_runs_50.append(base_test_loss_history[5])\n ti_base_runs_100.append(base_test_loss_history[10])\n \n ti_metainit_runs_10.append(metainit_test_loss_history[1])\n ti_metainit_runs_50.append(metainit_test_loss_history[5])\n ti_metainit_runs_100.append(metainit_test_loss_history[10])\n \n ti_maml_runs_10.append(maml_test_loss_history[1])\n ti_maml_runs_50.append(maml_test_loss_history[5])\n ti_maml_runs_100.append(maml_test_loss_history[10])", "_____no_output_____" ], [ "print(\"Baseline 10 epoch: \", np.mean(ti_base_runs_10), np.std(ti_base_runs_10, ddof=1))\nprint(\"Baseline 50 epoch: \", np.mean(ti_base_runs_50), np.std(ti_base_runs_50, ddof=1))\nprint(\"Baseline 100 epoch: \", np.mean(ti_base_runs_100), np.std(ti_base_runs_100, ddof=1))\nprint()\nprint(\"DeltaOrthogonal 10 epoch: \", np.mean(ti_deltaorthogonal_runs_10), np.std(ti_deltaorthogonal_runs_10, ddof=1))\nprint(\"DeltaOrthogonal 50 epoch: \", np.mean(ti_deltaorthogonal_runs_50), np.std(ti_deltaorthogonal_runs_50, ddof=1))\nprint(\"DeltaOrthogonal 100 epoch: \", np.mean(ti_deltaorthogonal_runs_100), np.std(ti_deltaorthogonal_runs_100, ddof=1))\nprint()\nprint(\"MetaInit 10 epoch: \", np.mean(ti_metainit_runs_10), np.std(ti_metainit_runs_10, ddof=1))\nprint(\"MetaInit 50 epoch: \", np.mean(ti_metainit_runs_50), np.std(ti_metainit_runs_50, ddof=1))\nprint(\"MetaInit 100 epoch: \", np.mean(ti_metainit_runs_100), np.std(ti_metainit_runs_100, ddof=1))\nprint()\nprint(\"DIMAML 10 epoch: \", np.mean(ti_maml_runs_10), np.std(ti_maml_runs_10, ddof=1))\nprint(\"DIMAML 50 epoch: \", np.mean(ti_maml_runs_50), np.std(ti_maml_runs_50, ddof=1))\nprint(\"DIMAML 100 epoch: \", np.mean(ti_maml_runs_100), np.std(ti_maml_runs_100, ddof=1))", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Autonomous Driving - Car Detection\n\nWelcome to the Week 3 programming assignment! In this notebook, you'll implement object detection using the very powerful YOLO model. Many of the ideas in this notebook are described in the two YOLO papers: [Redmon et al., 2016](https://arxiv.org/abs/1506.02640) and [Redmon and Farhadi, 2016](https://arxiv.org/abs/1612.08242). \n\n**By the end of this assignment, you'll be able to**:\n\n- Detect objects in a car detection dataset\n- Implement non-max suppression to increase accuracy\n- Implement intersection over union\n- Handle bounding boxes, a type of image annotation popular in deep learning ", "_____no_output_____" ], [ "## Table of Contents\n\n- [Packages](#0)\n- [1 - Problem Statement](#1)\n- [2 - YOLO](#2)\n - [2.1 - Model Details](#2-1)\n - [2.2 - Filtering with a Threshold on Class Scores](#2-2)\n - [Exercise 1 - yolo_filter_boxes](#ex-1)\n - [2.3 - Non-max Suppression](#2-3)\n - [Exercise 2 - iou](#ex-2)\n - [2.4 - YOLO Non-max Suppression](#2-4)\n - [Exercise 3 - yolo_non_max_suppression](#ex-3)\n - [2.5 - Wrapping Up the Filtering](#2-5)\n - [Exercise 4 - yolo_eval](#ex-4)\n- [3 - Test YOLO Pre-trained Model on Images](#3)\n - [3.1 - Defining Classes, Anchors and Image Shape](#3-1)\n - [3.2 - Loading a Pre-trained Model](#3-2)\n - [3.3 - Convert Output of the Model to Usable Bounding Box Tensors](#3-3)\n - [3.4 - Filtering Boxes](#3-4)\n - [3.5 - Run the YOLO on an Image](#3-5)\n- [4 - Summary for YOLO](#4)\n- [5 - References](#5)", "_____no_output_____" ], [ "<a name='0'></a>\n## Packages\n\nRun the following cell to load the packages and dependencies that will come in handy as you build the object detector!", "_____no_output_____" ] ], [ [ "import argparse\nimport os\nimport matplotlib.pyplot as plt\nfrom matplotlib.pyplot import imshow\nimport scipy.io\nimport scipy.misc\nimport numpy as np\nimport pandas as pd\nimport PIL\nfrom PIL import ImageFont, ImageDraw, Image\nimport tensorflow as tf\nfrom tensorflow.python.framework.ops import EagerTensor\n\nfrom tensorflow.keras.models import load_model\nfrom yad2k.models.keras_yolo import yolo_head\nfrom yad2k.utils.utils import draw_boxes, get_colors_for_classes, scale_boxes, read_classes, read_anchors, preprocess_image\n\n%matplotlib inline", "_____no_output_____" ] ], [ [ "<a name='1'></a>\n## 1 - Problem Statement\n\nYou are working on a self-driving car. Go you! As a critical component of this project, you'd like to first build a car detection system. To collect data, you've mounted a camera to the hood (meaning the front) of the car, which takes pictures of the road ahead every few seconds as you drive around. \n\n<center>\n<video width=\"400\" height=\"200\" src=\"nb_images/road_video_compressed2.mp4\" type=\"video/mp4\" controls>\n</video>\n</center>\n\n<caption><center> Pictures taken from a car-mounted camera while driving around Silicon Valley. <br> Dataset provided by <a href=\"https://www.drive.ai/\">drive.ai</a>.\n</center></caption>\n\nYou've gathered all these images into a folder and labelled them by drawing bounding boxes around every car you found. Here's an example of what your bounding boxes look like:\n\n<img src=\"nb_images/box_label.png\" style=\"width:500px;height:250;\">\n<caption><center> <u><b>Figure 1</u></b>: Definition of a box<br> </center></caption>\n\nIf there are 80 classes you want the object detector to recognize, you can represent the class label $c$ either as an integer from 1 to 80, or as an 80-dimensional vector (with 80 numbers) one component of which is 1, and the rest of which are 0. The video lectures used the latter representation; in this notebook, you'll use both representations, depending on which is more convenient for a particular step. \n\nIn this exercise, you'll discover how YOLO (\"You Only Look Once\") performs object detection, and then apply it to car detection. Because the YOLO model is very computationally expensive to train, the pre-trained weights are already loaded for you to use. ", "_____no_output_____" ], [ "<a name='2'></a>\n## 2 - YOLO", "_____no_output_____" ], [ "\"You Only Look Once\" (YOLO) is a popular algorithm because it achieves high accuracy while also being able to run in real time. This algorithm \"only looks once\" at the image in the sense that it requires only one forward propagation pass through the network to make predictions. After non-max suppression, it then outputs recognized objects together with the bounding boxes.\n\n<a name='2-1'></a>\n### 2.1 - Model Details\n\n#### Inputs and outputs\n- The **input** is a batch of images, and each image has the shape (m, 608, 608, 3)\n- The **output** is a list of bounding boxes along with the recognized classes. Each bounding box is represented by 6 numbers $(p_c, b_x, b_y, b_h, b_w, c)$ as explained above. If you expand $c$ into an 80-dimensional vector, each bounding box is then represented by 85 numbers. \n\n#### Anchor Boxes\n* Anchor boxes are chosen by exploring the training data to choose reasonable height/width ratios that represent the different classes. For this assignment, 5 anchor boxes were chosen for you (to cover the 80 classes), and stored in the file './model_data/yolo_anchors.txt'\n* The dimension for anchor boxes is the second to last dimension in the encoding: $(m, n_H,n_W,anchors,classes)$.\n* The YOLO architecture is: IMAGE (m, 608, 608, 3) -> DEEP CNN -> ENCODING (m, 19, 19, 5, 85). \n\n\n#### Encoding\nLet's look in greater detail at what this encoding represents. \n\n<img src=\"nb_images/architecture.png\" style=\"width:700px;height:400;\">\n<caption><center> <u><b> Figure 2 </u></b>: Encoding architecture for YOLO<br> </center></caption>\n\nIf the center/midpoint of an object falls into a grid cell, that grid cell is responsible for detecting that object.", "_____no_output_____" ], [ "Since you're using 5 anchor boxes, each of the 19 x19 cells thus encodes information about 5 boxes. Anchor boxes are defined only by their width and height.\n\nFor simplicity, you'll flatten the last two dimensions of the shape (19, 19, 5, 85) encoding, so the output of the Deep CNN is (19, 19, 425).\n\n<img src=\"nb_images/flatten.png\" style=\"width:700px;height:400;\">\n<caption><center> <u><b> Figure 3 </u></b>: Flattening the last two last dimensions<br> </center></caption>", "_____no_output_____" ], [ "#### Class score\n\nNow, for each box (of each cell) you'll compute the following element-wise product and extract a probability that the box contains a certain class. \nThe class score is $score_{c,i} = p_{c} \\times c_{i}$: the probability that there is an object $p_{c}$ times the probability that the object is a certain class $c_{i}$.\n\n<img src=\"nb_images/probability_extraction.png\" style=\"width:700px;height:400;\">\n<caption><center> <u><b>Figure 4</u></b>: Find the class detected by each box<br> </center></caption>\n\n##### Example of figure 4\n* In figure 4, let's say for box 1 (cell 1), the probability that an object exists is $p_{1}=0.60$. So there's a 60% chance that an object exists in box 1 (cell 1). \n* The probability that the object is the class \"category 3 (a car)\" is $c_{3}=0.73$. \n* The score for box 1 and for category \"3\" is $score_{1,3}=0.60 \\times 0.73 = 0.44$. \n* Let's say you calculate the score for all 80 classes in box 1, and find that the score for the car class (class 3) is the maximum. So you'll assign the score 0.44 and class \"3\" to this box \"1\".\n\n#### Visualizing classes\nHere's one way to visualize what YOLO is predicting on an image:\n\n- For each of the 19x19 grid cells, find the maximum of the probability scores (taking a max across the 80 classes, one maximum for each of the 5 anchor boxes).\n- Color that grid cell according to what object that grid cell considers the most likely.\n\nDoing this results in this picture: \n\n<img src=\"nb_images/proba_map.png\" style=\"width:300px;height:300;\">\n<caption><center> <u><b>Figure 5</u></b>: Each one of the 19x19 grid cells is colored according to which class has the largest predicted probability in that cell.<br> </center></caption>\n\nNote that this visualization isn't a core part of the YOLO algorithm itself for making predictions; it's just a nice way of visualizing an intermediate result of the algorithm. ", "_____no_output_____" ], [ "#### Visualizing bounding boxes\nAnother way to visualize YOLO's output is to plot the bounding boxes that it outputs. Doing that results in a visualization like this: \n\n<img src=\"nb_images/anchor_map.png\" style=\"width:200px;height:200;\">\n<caption><center> <u><b>Figure 6</u></b>: Each cell gives you 5 boxes. In total, the model predicts: 19x19x5 = 1805 boxes just by looking once at the image (one forward pass through the network)! Different colors denote different classes. <br> </center></caption>\n\n#### Non-Max suppression\nIn the figure above, the only boxes plotted are ones for which the model had assigned a high probability, but this is still too many boxes. You'd like to reduce the algorithm's output to a much smaller number of detected objects. \n\nTo do so, you'll use **non-max suppression**. Specifically, you'll carry out these steps: \n- Get rid of boxes with a low score. Meaning, the box is not very confident about detecting a class, either due to the low probability of any object, or low probability of this particular class.\n- Select only one box when several boxes overlap with each other and detect the same object.", "_____no_output_____" ], [ "<a name='2-2'></a>\n### 2.2 - Filtering with a Threshold on Class Scores\n\nYou're going to first apply a filter by thresholding, meaning you'll get rid of any box for which the class \"score\" is less than a chosen threshold. \n\nThe model gives you a total of 19x19x5x85 numbers, with each box described by 85 numbers. It's convenient to rearrange the (19,19,5,85) (or (19,19,425)) dimensional tensor into the following variables: \n- `box_confidence`: tensor of shape $(19, 19, 5, 1)$ containing $p_c$ (confidence probability that there's some object) for each of the 5 boxes predicted in each of the 19x19 cells.\n- `boxes`: tensor of shape $(19, 19, 5, 4)$ containing the midpoint and dimensions $(b_x, b_y, b_h, b_w)$ for each of the 5 boxes in each cell.\n- `box_class_probs`: tensor of shape $(19, 19, 5, 80)$ containing the \"class probabilities\" $(c_1, c_2, ... c_{80})$ for each of the 80 classes for each of the 5 boxes per cell.\n\n<a name='ex-1'></a>\n### Exercise 1 - yolo_filter_boxes\n\nImplement `yolo_filter_boxes()`.\n1. Compute box scores by doing the elementwise product as described in Figure 4 ($p \\times c$). \nThe following code may help you choose the right operator: \n```python\na = np.random.randn(19, 19, 5, 1)\nb = np.random.randn(19, 19, 5, 80)\nc = a * b # shape of c will be (19, 19, 5, 80)\n```\nThis is an example of **broadcasting** (multiplying vectors of different sizes).\n\n2. For each box, find:\n - the index of the class with the maximum box score\n - the corresponding box score\n \n **Useful References**\n * [tf.math.argmax](https://www.tensorflow.org/api_docs/python/tf/math/argmax)\n * [tf.math.reduce_max](https://www.tensorflow.org/api_docs/python/tf/math/reduce_max)\n\n **Helpful Hints**\n * For the `axis` parameter of `argmax` and `reduce_max`, if you want to select the **last** axis, one way to do so is to set `axis=-1`. This is similar to Python array indexing, where you can select the last position of an array using `arrayname[-1]`.\n * Applying `reduce_max` normally collapses the axis for which the maximum is applied. `keepdims=False` is the default option, and allows that dimension to be removed. You don't need to keep the last dimension after applying the maximum here.\n\n\n3. Create a mask by using a threshold. As a reminder: `([0.9, 0.3, 0.4, 0.5, 0.1] < 0.4)` returns: `[False, True, False, False, True]`. The mask should be `True` for the boxes you want to keep. \n\n4. Use TensorFlow to apply the mask to `box_class_scores`, `boxes` and `box_classes` to filter out the boxes you don't want. You should be left with just the subset of boxes you want to keep. \n\n **One more useful reference**:\n * [tf.boolean mask](https://www.tensorflow.org/api_docs/python/tf/boolean_mask) \n\n **And one more helpful hint**: :) \n * For the `tf.boolean_mask`, you can keep the default `axis=None`.", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: yolo_filter_boxes\n\ndef yolo_filter_boxes(boxes, box_confidence, box_class_probs, threshold = 0.6):\n \"\"\"Filters YOLO boxes by thresholding on object and class confidence.\n \n Arguments:\n boxes -- tensor of shape (19, 19, 5, 4)\n box_confidence -- tensor of shape (19, 19, 5, 1)\n box_class_probs -- tensor of shape (19, 19, 5, 80)\n threshold -- real value, if [ highest class probability score < threshold],\n then get rid of the corresponding box\n\n Returns:\n scores -- tensor of shape (None,), containing the class probability score for selected boxes\n boxes -- tensor of shape (None, 4), containing (b_x, b_y, b_h, b_w) coordinates of selected boxes\n classes -- tensor of shape (None,), containing the index of the class detected by the selected boxes\n\n Note: \"None\" is here because you don't know the exact number of selected boxes, as it depends on the threshold. \n For example, the actual output size of scores would be (10,) if there are 10 boxes.\n \"\"\"\n \n x = 10\n y = tf.constant(100)\n \n # YOUR CODE STARTS HERE\n\n # Step 1: Compute box scores\n ##(≈ 1 line)\n box_scores = box_class_probs*box_confidence\n \n # Step 2: Find the box_classes using the max box_scores, keep track of the corresponding score\n ##(≈ 2 lines)\n box_classes = tf.math.argmax(box_scores,axis=-1)\n box_class_scores = tf.math.reduce_max(box_scores,axis=-1)\n \n # Step 3: Create a filtering mask based on \"box_class_scores\" by using \"threshold\". The mask should have the\n # same dimension as box_class_scores, and be True for the boxes you want to keep (with probability >= threshold)\n ## (≈ 1 line)\n filtering_mask = (box_class_scores >= threshold)\n \n # Step 4: Apply the mask to box_class_scores, boxes and box_classes\n ## (≈ 3 lines)\n scores = tf.boolean_mask(box_class_scores,filtering_mask)\n boxes = tf.boolean_mask(boxes,filtering_mask)\n classes = tf.boolean_mask(box_classes,filtering_mask)\n \n # YOUR CODE ENDS HERE\n \n return scores, boxes, classes", "_____no_output_____" ], [ "tf.random.set_seed(10)\nbox_confidence = tf.random.normal([19, 19, 5, 1], mean=1, stddev=4, seed = 1)\nboxes = tf.random.normal([19, 19, 5, 4], mean=1, stddev=4, seed = 1)\nbox_class_probs = tf.random.normal([19, 19, 5, 80], mean=1, stddev=4, seed = 1)\nscores, boxes, classes = yolo_filter_boxes(boxes, box_confidence, box_class_probs, threshold = 0.5)\nprint(\"scores[2] = \" + str(scores[2].numpy()))\nprint(\"boxes[2] = \" + str(boxes[2].numpy()))\nprint(\"classes[2] = \" + str(classes[2].numpy()))\nprint(\"scores.shape = \" + str(scores.shape))\nprint(\"boxes.shape = \" + str(boxes.shape))\nprint(\"classes.shape = \" + str(classes.shape))\n\nassert type(scores) == EagerTensor, \"Use tensorflow functions\"\nassert type(boxes) == EagerTensor, \"Use tensorflow functions\"\nassert type(classes) == EagerTensor, \"Use tensorflow functions\"\n\nassert scores.shape == (1789,), \"Wrong shape in scores\"\nassert boxes.shape == (1789, 4), \"Wrong shape in boxes\"\nassert classes.shape == (1789,), \"Wrong shape in classes\"\n\nassert np.isclose(scores[2].numpy(), 9.270486), \"Values are wrong on scores\"\nassert np.allclose(boxes[2].numpy(), [4.6399336, 3.2303846, 4.431282, -2.202031]), \"Values are wrong on boxes\"\nassert classes[2].numpy() == 8, \"Values are wrong on classes\"\n\nprint(\"\\033[92m All tests passed!\")\n", "_____no_output_____" ] ], [ [ "**Expected Output**:\n\n<table>\n <tr>\n <td>\n <b>scores[2]</b>\n </td>\n <td>\n 9.270486\n </td>\n </tr>\n <tr>\n <td>\n <b>boxes[2]</b>\n </td>\n <td>\n [ 4.6399336 3.2303846 4.431282 -2.202031 ]\n </td>\n </tr>\n <tr>\n <td>\n <b>classes[2]</b>\n </td>\n <td>\n 8\n </td>\n </tr>\n <tr>\n <td>\n <b>scores.shape</b>\n </td>\n <td>\n (1789,)\n </td>\n </tr>\n <tr>\n <td>\n <b>boxes.shape</b>\n </td>\n <td>\n (1789, 4)\n </td>\n </tr>\n <tr>\n <td>\n <b>classes.shape</b>\n </td>\n <td>\n (1789,)\n </td>\n </tr>\n\n</table>", "_____no_output_____" ], [ "**Note** In the test for `yolo_filter_boxes`, you're using random numbers to test the function. In real data, the `box_class_probs` would contain non-zero values between 0 and 1 for the probabilities. The box coordinates in `boxes` would also be chosen so that lengths and heights are non-negative.", "_____no_output_____" ], [ "<a name='2-3'></a>\n### 2.3 - Non-max Suppression\n\nEven after filtering by thresholding over the class scores, you still end up with a lot of overlapping boxes. A second filter for selecting the right boxes is called non-maximum suppression (NMS). ", "_____no_output_____" ], [ "<img src=\"nb_images/non-max-suppression.png\" style=\"width:500px;height:400;\">\n<caption><center> <u> <b>Figure 7</b> </u>: In this example, the model has predicted 3 cars, but it's actually 3 predictions of the same car. Running non-max suppression (NMS) will select only the most accurate (highest probability) of the 3 boxes. <br> </center></caption>\n", "_____no_output_____" ], [ "Non-max suppression uses the very important function called **\"Intersection over Union\"**, or IoU.\n<img src=\"nb_images/iou.png\" style=\"width:500px;height:400;\">\n<caption><center> <u> <b>Figure 8</b> </u>: Definition of \"Intersection over Union\". <br> </center></caption>\n\n<a name='ex-2'></a>\n### Exercise 2 - iou\n\nImplement `iou()` \n\nSome hints:\n- This code uses the convention that (0,0) is the top-left corner of an image, (1,0) is the upper-right corner, and (1,1) is the lower-right corner. In other words, the (0,0) origin starts at the top left corner of the image. As x increases, you move to the right. As y increases, you move down.\n- For this exercise, a box is defined using its two corners: upper left $(x_1, y_1)$ and lower right $(x_2,y_2)$, instead of using the midpoint, height and width. This makes it a bit easier to calculate the intersection.\n- To calculate the area of a rectangle, multiply its height $(y_2 - y_1)$ by its width $(x_2 - x_1)$. Since $(x_1,y_1)$ is the top left and $x_2,y_2$ are the bottom right, these differences should be non-negative.\n- To find the **intersection** of the two boxes $(xi_{1}, yi_{1}, xi_{2}, yi_{2})$: \n - Feel free to draw some examples on paper to clarify this conceptually.\n - The top left corner of the intersection $(xi_{1}, yi_{1})$ is found by comparing the top left corners $(x_1, y_1)$ of the two boxes and finding a vertex that has an x-coordinate that is closer to the right, and y-coordinate that is closer to the bottom.\n - The bottom right corner of the intersection $(xi_{2}, yi_{2})$ is found by comparing the bottom right corners $(x_2,y_2)$ of the two boxes and finding a vertex whose x-coordinate is closer to the left, and the y-coordinate that is closer to the top.\n - The two boxes **may have no intersection**. You can detect this if the intersection coordinates you calculate end up being the top right and/or bottom left corners of an intersection box. Another way to think of this is if you calculate the height $(y_2 - y_1)$ or width $(x_2 - x_1)$ and find that at least one of these lengths is negative, then there is no intersection (intersection area is zero). \n - The two boxes may intersect at the **edges or vertices**, in which case the intersection area is still zero. This happens when either the height or width (or both) of the calculated intersection is zero.\n\n\n**Additional Hints**\n\n- `xi1` = **max**imum of the x1 coordinates of the two boxes\n- `yi1` = **max**imum of the y1 coordinates of the two boxes\n- `xi2` = **min**imum of the x2 coordinates of the two boxes\n- `yi2` = **min**imum of the y2 coordinates of the two boxes\n- `inter_area` = You can use `max(height, 0)` and `max(width, 0)`\n", "_____no_output_____" ] ], [ [ "#########################################################################\n######################## USELESS BELOW ##################################\n#########################################################################", "_____no_output_____" ], [ "# GRADED FUNCTION: iou\n\ndef iou(box1, box2):\n \"\"\"Implement the intersection over union (IoU) between box1 and box2\n    \n Arguments:\n box1 -- first box, list object with coordinates (box1_x1, box1_y1, box1_x2, box_1_y2)\n    box2 -- second box, list object with coordinates (box2_x1, box2_y1, box2_x2, box2_y2)\n    \"\"\"\n\n\n (box1_x1, box1_y1, box1_x2, box1_y2) = box1\n (box2_x1, box2_y1, box2_x2, box2_y2) = box2\n\n # YOUR CODE STARTS HERE\n \n # Calculate the (yi1, xi1, yi2, xi2) coordinates of the intersection of box1 and box2. Calculate its Area.\n ##(≈ 7 lines)\n xi1 = max(box1_x1,box2_x1)\n yi1 = max(box1_y1,box2_y1)\n xi2 = min(box1_x2,box2_x2)\n yi2 = min(box1_y2,box2_y2)\n inter_width = max(0,yi2 - yi1)\n inter_height = max(0,xi2 - xi1)\n inter_area = inter_width*inter_height\n\n # Calculate the Union area by using Formula: Union(A,B) = A + B - Inter(A,B)\n ## (≈ 3 lines)\n box1_area = (box1_x2-box1_x1)*((box1_y2-box1_y1))\n box2_area = (box2_x2-box2_x1)*((box2_y2-box2_y1))\n union_area = box1_area + box2_area - inter_area\n \n # compute the IoU\n ## (≈ 1 line)\n iou = inter_area/union_area\n \n # YOUR CODE ENDS HERE\n \n return iou", "_____no_output_____" ], [ "## Test case 1: boxes intersect\nbox1 = (2, 1, 4, 3)\nbox2 = (1, 2, 3, 4)\n\nprint(\"iou for intersecting boxes = \" + str(iou(box1, box2)))\nassert iou(box1, box2) < 1, \"The intersection area must be always smaller or equal than the union area.\"\nassert np.isclose(iou(box1, box2), 0.14285714), \"Wrong value. Check your implementation. Problem with intersecting boxes\"\n\n## Test case 2: boxes do not intersect\nbox1 = (1,2,3,4)\nbox2 = (5,6,7,8)\nprint(\"iou for non-intersecting boxes = \" + str(iou(box1,box2)))\nassert iou(box1, box2) == 0, \"Intersection must be 0\"\n\n## Test case 3: boxes intersect at vertices only\nbox1 = (1,1,2,2)\nbox2 = (2,2,3,3)\nprint(\"iou for boxes that only touch at vertices = \" + str(iou(box1,box2)))\nassert iou(box1, box2) == 0, \"Intersection at vertices must be 0\"\n\n## Test case 4: boxes intersect at edge only\nbox1 = (1,1,3,3)\nbox2 = (2,3,3,4)\nprint(\"iou for boxes that only touch at edges = \" + str(iou(box1,box2)))\nassert iou(box1, box2) == 0, \"Intersection at edges must be 0\"\n\nprint(\"\\033[92m All tests passed!\")\n\n", "_____no_output_____" ] ], [ [ "**Expected Output**:\n\n```\niou for intersecting boxes = 0.14285714285714285\niou for non-intersecting boxes = 0.0\niou for boxes that only touch at vertices = 0.0\niou for boxes that only touch at edges = 0.0\n```", "_____no_output_____" ], [ "<a name='2-4'></a>\n### 2.4 - YOLO Non-max Suppression\n\nYou are now ready to implement non-max suppression. The key steps are: \n1. Select the box that has the highest score.\n2. Compute the overlap of this box with all other boxes, and remove boxes that overlap significantly (iou >= `iou_threshold`).\n3. Go back to step 1 and iterate until there are no more boxes with a lower score than the currently selected box.\n\nThis will remove all boxes that have a large overlap with the selected boxes. Only the \"best\" boxes remain.\n\n<a name='ex-3'></a>\n### Exercise 3 - yolo_non_max_suppression\n\nImplement `yolo_non_max_suppression()` using TensorFlow. TensorFlow has two built-in functions that are used to implement non-max suppression (so you don't actually need to use your `iou()` implementation):\n\n**Reference documentation**: \n\n- [tf.image.non_max_suppression()](https://www.tensorflow.org/api_docs/python/tf/image/non_max_suppression)\n```\ntf.image.non_max_suppression(\n boxes,\n scores,\n max_output_size,\n iou_threshold=0.5,\n name=None\n)\n```\nNote that in the version of TensorFlow used here, there is no parameter `score_threshold` (it's shown in the documentation for the latest version) so trying to set this value will result in an error message: *got an unexpected keyword argument `score_threshold`.*\n\n- [tf.gather()](https://www.tensorflow.org/api_docs/python/tf/gather)\n```\nkeras.gather(\n reference,\n indices\n)\n```", "_____no_output_____" ] ], [ [ "# GRADED FUNCTION: yolo_non_max_suppression\n\ndef yolo_non_max_suppression(scores, boxes, classes, max_boxes = 10, iou_threshold = 0.5):\n \"\"\"\n Applies Non-max suppression (NMS) to set of boxes\n \n Arguments:\n scores -- tensor of shape (None,), output of yolo_filter_boxes()\n boxes -- tensor of shape (None, 4), output of yolo_filter_boxes() that have been scaled to the image size (see later)\n classes -- tensor of shape (None,), output of yolo_filter_boxes()\n max_boxes -- integer, maximum number of predicted boxes you'd like\n iou_threshold -- real value, \"intersection over union\" threshold used for NMS filtering\n \n Returns:\n scores -- tensor of shape (, None), predicted score for each box\n boxes -- tensor of shape (4, None), predicted box coordinates\n classes -- tensor of shape (, None), predicted class for each box\n \n Note: The \"None\" dimension of the output tensors has obviously to be less than max_boxes. Note also that this\n function will transpose the shapes of scores, boxes, classes. This is made for convenience.\n \"\"\"\n \n max_boxes_tensor = tf.Variable(max_boxes, dtype='int32') # tensor to be used in tf.image.non_max_suppression()\n \n # Use tf.image.non_max_suppression() to get the list of indices corresponding to boxes you keep\n ##(≈ 1 line)\n nms_indices = tf.image.non_max_suppression(boxes,scores,max_boxes_tensor,iou_threshold)\n \n # Use tf.gather() to select only nms_indices from scores, boxes and classes\n ##(≈ 3 lines)\n scores = tf.gather(scores,nms_indices)\n boxes = tf.gather(boxes,nms_indices)\n classes = tf.gather(classes,nms_indices)\n # YOUR CODE STARTS HERE\n \n \n # YOUR CODE ENDS HERE\n\n \n return scores, boxes, classes", "_____no_output_____" ], [ "tf.random.set_seed(10)\nscores = tf.random.normal([54,], mean=1, stddev=4, seed = 1)\nboxes = tf.random.normal([54, 4], mean=1, stddev=4, seed = 1)\nclasses = tf.random.normal([54,], mean=1, stddev=4, seed = 1)\nscores, boxes, classes = yolo_non_max_suppression(scores, boxes, classes)\n\nassert type(scores) == EagerTensor, \"Use tensoflow functions\"\nprint(\"scores[2] = \" + str(scores[2].numpy()))\nprint(\"boxes[2] = \" + str(boxes[2].numpy()))\nprint(\"classes[2] = \" + str(classes[2].numpy()))\nprint(\"scores.shape = \" + str(scores.numpy().shape))\nprint(\"boxes.shape = \" + str(boxes.numpy().shape))\nprint(\"classes.shape = \" + str(classes.numpy().shape))\n\nassert type(scores) == EagerTensor, \"Use tensoflow functions\"\nassert type(boxes) == EagerTensor, \"Use tensoflow functions\"\nassert type(classes) == EagerTensor, \"Use tensoflow functions\"\n\nassert scores.shape == (10,), \"Wrong shape\"\nassert boxes.shape == (10, 4), \"Wrong shape\"\nassert classes.shape == (10,), \"Wrong shape\"\n\nassert np.isclose(scores[2].numpy(), 8.147684), \"Wrong value on scores\"\nassert np.allclose(boxes[2].numpy(), [ 6.0797963, 3.743308, 1.3914018, -0.34089637]), \"Wrong value on boxes\"\nassert np.isclose(classes[2].numpy(), 1.7079165), \"Wrong value on classes\"\n\nprint(\"\\033[92m All tests passed!\")\n", "_____no_output_____" ] ], [ [ "**Expected Output**:\n\n<table>\n <tr>\n <td>\n <b>scores[2]</b>\n </td>\n <td>\n 8.147684\n </td>\n </tr>\n <tr>\n <td>\n <b>boxes[2]</b>\n </td>\n <td>\n [ 6.0797963 3.743308 1.3914018 -0.34089637]\n </td>\n </tr>\n <tr>\n <td>\n <b>classes[2]</b>\n </td>\n <td>\n 1.7079165\n </td>\n </tr>\n <tr>\n <td>\n <b>scores.shape</b>\n </td>\n <td>\n (10,)\n </td>\n </tr>\n <tr>\n <td>\n <b>boxes.shape</b>\n </td>\n <td>\n (10, 4)\n </td>\n </tr>\n <tr>\n <td>\n <b>classes.shape</b>\n </td>\n <td>\n (10,)\n </td>\n </tr>\n\n</table>", "_____no_output_____" ], [ "<a name='2-5'></a>\n### 2.5 - Wrapping Up the Filtering\n\nIt's time to implement a function taking the output of the deep CNN (the 19x19x5x85 dimensional encoding) and filtering through all the boxes using the functions you've just implemented. \n\n<a name='ex-4'></a>\n### Exercise 4 - yolo_eval\n\nImplement `yolo_eval()` which takes the output of the YOLO encoding and filters the boxes using score threshold and NMS. There's just one last implementational detail you have to know. There're a few ways of representing boxes, such as via their corners or via their midpoint and height/width. YOLO converts between a few such formats at different times, using the following functions (which are provided): \n\n```python\nboxes = yolo_boxes_to_corners(box_xy, box_wh) \n```\nwhich converts the yolo box coordinates (x,y,w,h) to box corners' coordinates (x1, y1, x2, y2) to fit the input of `yolo_filter_boxes`\n```python\nboxes = scale_boxes(boxes, image_shape)\n```\nYOLO's network was trained to run on 608x608 images. If you are testing this data on a different size image -- for example, the car detection dataset had 720x1280 images -- this step rescales the boxes so that they can be plotted on top of the original 720x1280 image. \n\nDon't worry about these two functions; you'll see where they need to be called below. ", "_____no_output_____" ] ], [ [ "def yolo_boxes_to_corners(box_xy, box_wh):\n \"\"\"Convert YOLO box predictions to bounding box corners.\"\"\"\n box_mins = box_xy - (box_wh / 2.)\n box_maxes = box_xy + (box_wh / 2.)\n\n return tf.keras.backend.concatenate([\n box_mins[..., 1:2], # y_min\n box_mins[..., 0:1], # x_min\n box_maxes[..., 1:2], # y_max\n box_maxes[..., 0:1] # x_max\n ])\n", "_____no_output_____" ], [ "# GRADED FUNCTION: yolo_eval\n\ndef yolo_eval(yolo_outputs, image_shape = (720, 1280), max_boxes=10, score_threshold=.6, iou_threshold=.5):\n \"\"\"\n Converts the output of YOLO encoding (a lot of boxes) to your predicted boxes along with their scores, box coordinates and classes.\n \n Arguments:\n yolo_outputs -- output of the encoding model (for image_shape of (608, 608, 3)), contains 4 tensors:\n box_xy: tensor of shape (None, 19, 19, 5, 2)\n box_wh: tensor of shape (None, 19, 19, 5, 2)\n box_confidence: tensor of shape (None, 19, 19, 5, 1)\n box_class_probs: tensor of shape (None, 19, 19, 5, 80)\n image_shape -- tensor of shape (2,) containing the input shape, in this notebook we use (608., 608.) (has to be float32 dtype)\n max_boxes -- integer, maximum number of predicted boxes you'd like\n score_threshold -- real value, if [ highest class probability score < threshold], then get rid of the corresponding box\n iou_threshold -- real value, \"intersection over union\" threshold used for NMS filtering\n \n Returns:\n scores -- tensor of shape (None, ), predicted score for each box\n boxes -- tensor of shape (None, 4), predicted box coordinates\n classes -- tensor of shape (None,), predicted class for each box\n \"\"\"\n \n \n # Retrieve outputs of the YOLO model (≈1 line)\n box_xy, box_wh, box_confidence, box_class_probs = yolo_outputs\n\n # Convert boxes to be ready for filtering functions (convert boxes box_xy and box_wh to corner coordinates)\n boxes = yolo_boxes_to_corners(box_xy, box_wh)\n\n # Use one of the functions you've implemented to perform Score-filtering with a threshold of score_threshold (≈1 line)\n scores, boxes, classes = yolo_filter_boxes(boxes, box_confidence, box_class_probs, score_threshold)\n \n # Scale boxes back to original image shape (720, 1280 or whatever)\n boxes = scale_boxes(boxes, image_shape) # Network was trained to run on 608x608 images\n\n # Use one of the functions you've implemented to perform Non-max suppression with \n # maximum number of boxes set to max_boxes and a threshold of iou_threshold (≈1 line)\n scores, boxes, classes = yolo_non_max_suppression(scores, boxes, classes, max_boxes, iou_threshold)\n \n # YOUR CODE STARTS HERE\n \n \n # YOUR CODE ENDS HERE\n \n return scores, boxes, classes", "_____no_output_____" ], [ "tf.random.set_seed(10)\nyolo_outputs = (tf.random.normal([19, 19, 5, 2], mean=1, stddev=4, seed = 1),\n tf.random.normal([19, 19, 5, 2], mean=1, stddev=4, seed = 1),\n tf.random.normal([19, 19, 5, 1], mean=1, stddev=4, seed = 1),\n tf.random.normal([19, 19, 5, 80], mean=1, stddev=4, seed = 1))\nscores, boxes, classes = yolo_eval(yolo_outputs)\nprint(\"scores[2] = \" + str(scores[2].numpy()))\nprint(\"boxes[2] = \" + str(boxes[2].numpy()))\nprint(\"classes[2] = \" + str(classes[2].numpy()))\nprint(\"scores.shape = \" + str(scores.numpy().shape))\nprint(\"boxes.shape = \" + str(boxes.numpy().shape))\nprint(\"classes.shape = \" + str(classes.numpy().shape))\n\nassert type(scores) == EagerTensor, \"Use tensoflow functions\"\nassert type(boxes) == EagerTensor, \"Use tensoflow functions\"\nassert type(classes) == EagerTensor, \"Use tensoflow functions\"\n\nassert scores.shape == (10,), \"Wrong shape\"\nassert boxes.shape == (10, 4), \"Wrong shape\"\nassert classes.shape == (10,), \"Wrong shape\"\n \nassert np.isclose(scores[2].numpy(), 171.60194), \"Wrong value on scores\"\nassert np.allclose(boxes[2].numpy(), [-1240.3483, -3212.5881, -645.78, 2024.3052]), \"Wrong value on boxes\"\nassert np.isclose(classes[2].numpy(), 16), \"Wrong value on classes\"\n \nprint(\"\\033[92m All tests passed!\")", "_____no_output_____" ] ], [ [ "**Expected Output**:\n\n<table>\n <tr>\n <td>\n <b>scores[2]</b>\n </td>\n <td>\n 171.60194\n </td>\n </tr>\n <tr>\n <td>\n <b>boxes[2]</b>\n </td>\n <td>\n [-1240.3483 -3212.5881 -645.78 2024.3052]\n </td>\n </tr>\n <tr>\n <td>\n <b>classes[2]</b>\n </td>\n <td>\n 16\n </td>\n </tr> \n <tr>\n <td>\n <b>scores.shape</b>\n </td>\n <td>\n (10,)\n </td>\n </tr>\n <tr>\n <td>\n <b>boxes.shape</b>\n </td>\n <td>\n (10, 4)\n </td>\n </tr>\n <tr>\n <td>\n <b>classes.shape</b>\n </td>\n <td>\n (10,)\n </td>\n </tr>\n\n</table>", "_____no_output_____" ], [ "<a name='3'></a>\n## 3 - Test YOLO Pre-trained Model on Images\n\nIn this section, you are going to use a pre-trained model and test it on the car detection dataset. ", "_____no_output_____" ], [ "<a name='3-1'></a>\n### 3.1 - Defining Classes, Anchors and Image Shape\n\nYou're trying to detect 80 classes, and are using 5 anchor boxes. The information on the 80 classes and 5 boxes is gathered in two files: \"coco_classes.txt\" and \"yolo_anchors.txt\". You'll read class names and anchors from text files. The car detection dataset has 720x1280 images, which are pre-processed into 608x608 images.", "_____no_output_____" ] ], [ [ "class_names = read_classes(\"model_data/coco_classes.txt\")\nanchors = read_anchors(\"model_data/yolo_anchors.txt\")\nmodel_image_size = (608, 608) # Same as yolo_model input layer size", "_____no_output_____" ] ], [ [ "<a name='3-2'></a>\n### 3.2 - Loading a Pre-trained Model\n\nTraining a YOLO model takes a very long time and requires a fairly large dataset of labelled bounding boxes for a large range of target classes. You are going to load an existing pre-trained Keras YOLO model stored in \"yolo.h5\". These weights come from the official YOLO website, and were converted using a function written by Allan Zelener. References are at the end of this notebook. Technically, these are the parameters from the \"YOLOv2\" model, but are simply referred to as \"YOLO\" in this notebook.\n\nRun the cell below to load the model from this file.", "_____no_output_____" ] ], [ [ "yolo_model = load_model(\"model_data/\", compile=False)", "_____no_output_____" ] ], [ [ "This loads the weights of a trained YOLO model. Here's a summary of the layers your model contains:", "_____no_output_____" ] ], [ [ "yolo_model.summary()", "_____no_output_____" ] ], [ [ "**Note**: On some computers, you may see a warning message from Keras. Don't worry about it if you do -- this is fine!\n\n**Reminder**: This model converts a preprocessed batch of input images (shape: (m, 608, 608, 3)) into a tensor of shape (m, 19, 19, 5, 85) as explained in Figure (2).", "_____no_output_____" ], [ "<a name='3-3'></a>\n### 3.3 - Convert Output of the Model to Usable Bounding Box Tensors\n\nThe output of `yolo_model` is a (m, 19, 19, 5, 85) tensor that needs to pass through non-trivial processing and conversion. You will need to call `yolo_head` to format the encoding of the model you got from `yolo_model` into something decipherable:\n\n`yolo_model_outputs = yolo_model(image_data)`\n\n`yolo_outputs = yolo_head(yolo_model_outputs, anchors, len(class_names))`\n\nThe variable `yolo_outputs` will be defined as a set of 4 tensors that you can then use as input by your yolo_eval function. If you are curious about how yolo_head is implemented, you can find the function definition in the file `keras_yolo.py`. The file is also located in your workspace in this path: `yad2k/models/keras_yolo.py`.", "_____no_output_____" ], [ "<a name='3-4'></a>\n### 3.4 - Filtering Boxes\n\n`yolo_outputs` gave you all the predicted boxes of `yolo_model` in the correct format. To perform filtering and select only the best boxes, you will call `yolo_eval`, which you had previously implemented, to do so:\n\n out_scores, out_boxes, out_classes = yolo_eval(yolo_outputs, [image.size[1], image.size[0]], 10, 0.3, 0.5)", "_____no_output_____" ], [ "<a name='3-5'></a>\n### 3.5 - Run the YOLO on an Image\n\nLet the fun begin! You will create a graph that can be summarized as follows:\n\n`yolo_model.input` is given to `yolo_model`. The model is used to compute the output `yolo_model.output`\n`yolo_model.output` is processed by `yolo_head`. It gives you `yolo_outputs`\n`yolo_outputs` goes through a filtering function, `yolo_eval`. It outputs your predictions: `out_scores`, `out_boxes`, `out_classes`.", "_____no_output_____" ], [ "Now, we have implemented for you the `predict(image_file)` function, which runs the graph to test YOLO on an image to compute `out_scores`, `out_boxes`, `out_classes`.\n\nThe code below also uses the following function:\n\n image, image_data = preprocess_image(\"images/\" + image_file, model_image_size = (608, 608))\nwhich opens the image file and scales, reshapes and normalizes the image. It returns the outputs:\n\n image: a python (PIL) representation of your image used for drawing boxes. You won't need to use it.\n image_data: a numpy-array representing the image. This will be the input to the CNN.", "_____no_output_____" ] ], [ [ "def predict(image_file):\n \"\"\"\n Runs the graph to predict boxes for \"image_file\". Prints and plots the predictions.\n \n Arguments:\n image_file -- name of an image stored in the \"images\" folder.\n \n Returns:\n out_scores -- tensor of shape (None, ), scores of the predicted boxes\n out_boxes -- tensor of shape (None, 4), coordinates of the predicted boxes\n out_classes -- tensor of shape (None, ), class index of the predicted boxes\n \n Note: \"None\" actually represents the number of predicted boxes, it varies between 0 and max_boxes. \n \"\"\"\n\n # Preprocess your image\n image, image_data = preprocess_image(\"images/\" + image_file, model_image_size = (608, 608))\n \n yolo_model_outputs = yolo_model(image_data) # It's output is of shape (m, 19, 19, 5, 85) \n # But yolo_eval takes input a tensor contains 4 tensors: box_xy,box_wh, box_confidence & box_class_probs\n yolo_outputs = yolo_head(yolo_model_outputs, anchors, len(class_names))\n \n out_scores, out_boxes, out_classes = yolo_eval(yolo_outputs, [image.size[1], image.size[0]], 10, 0.3, 0.5)\n\n # Print predictions info\n print('Found {} boxes for {}'.format(len(out_boxes), \"images/\" + image_file))\n # Generate colors for drawing bounding boxes.\n colors = get_colors_for_classes(len(class_names))\n # Draw bounding boxes on the image file\n #draw_boxes2(image, out_scores, out_boxes, out_classes, class_names, colors, image_shape)\n draw_boxes(image, out_boxes, out_classes, class_names, out_scores)\n # Save the predicted bounding box on the image\n image.save(os.path.join(\"out\", str(image_file).split('.')[0]+\"_annotated.\" +str(image_file).split('.')[1] ), quality=100)\n # Display the results in the notebook\n output_image = Image.open(os.path.join(\"out\", str(image_file).split('.')[0]+\"_annotated.\" +str(image_file).split('.')[1] ))\n imshow(output_image)\n\n return out_scores, out_boxes, out_classes", "_____no_output_____" ] ], [ [ "Run the following cell on the \"test.jpg\" image to verify that your function is correct.", "_____no_output_____" ] ], [ [ "out_scores, out_boxes, out_classes = predict(\"0001.jpg\")", "_____no_output_____" ] ], [ [ "**Expected Output**:\n\n<table>\n <tr>\n <td>\n <b>Found 10 boxes for images/test.jpg</b>\n </td>\n </tr>\n <tr>\n <td>\n <b>car</b>\n </td>\n <td>\n 0.89 (367, 300) (745, 648)\n </td>\n </tr>\n <tr>\n <td>\n <b>car</b>\n </td>\n <td>\n 0.80 (761, 282) (942, 412)\n </td>\n </tr>\n <tr>\n <td>\n <b>car</b>\n </td>\n <td>\n 0.74 (159, 303) (346, 440)\n </td>\n </tr>\n <tr>\n <td>\n <b>car</b>\n </td>\n <td>\n 0.70 (947, 324) (1280, 705)\n </td>\n </tr>\n <tr>\n <td>\n <b>bus</b>\n </td>\n <td>\n 0.67 (5, 266) (220, 407)\n </td>\n </tr>\n <tr>\n <td>\n <b>car</b>\n </td>\n <td>\n 0.66 (706, 279) (786, 350)\n </td>\n </tr>\n <tr>\n <td>\n <b>car</b>\n </td>\n <td>\n 0.60 (925, 285) (1045, 374)\n </td>\n </tr>\n <tr>\n <td>\n <b>car</b>\n </td>\n <td>\n 0.44 (336, 296) (378, 335)\n </td>\n </tr>\n <tr>\n <td>\n <b>car</b>\n </td>\n <td>\n 0.37 (965, 273) (1022, 292)\n </td>\n </tr>\n <tr>\n <td>\n <b>traffic light</b>\n </td>\n <td>\n 00.36 (681, 195) (692, 214)\n </td>\n </tr>\n</table>", "_____no_output_____" ], [ "The model you've just run is actually able to detect 80 different classes listed in \"coco_classes.txt\". To test the model on your own images:\n 1. Click on \"File\" in the upper bar of this notebook, then click \"Open\" to go on your Coursera Hub.\n 2. Add your image to this Jupyter Notebook's directory, in the \"images\" folder\n 3. Write your image's name in the cell above code\n 4. Run the code and see the output of the algorithm!\n\nIf you were to run your session in a for loop over all your images. Here's what you would get:\n\n<center>\n<video width=\"400\" height=\"200\" src=\"nb_images/pred_video_compressed2.mp4\" type=\"video/mp4\" controls>\n</video>\n</center>\n\n<caption><center> Predictions of the YOLO model on pictures taken from a camera while driving around the Silicon Valley <br> Thanks to <a href=\"https://www.drive.ai/\">drive.ai</a> for providing this dataset! </center></caption>", "_____no_output_____" ], [ "<a name='4'></a>\n## 4 - Summary for YOLO\n\n- Input image (608, 608, 3)\n- The input image goes through a CNN, resulting in a (19,19,5,85) dimensional output. \n- After flattening the last two dimensions, the output is a volume of shape (19, 19, 425):\n - Each cell in a 19x19 grid over the input image gives 425 numbers. \n - 425 = 5 x 85 because each cell contains predictions for 5 boxes, corresponding to 5 anchor boxes, as seen in lecture. \n - 85 = 5 + 80 where 5 is because $(p_c, b_x, b_y, b_h, b_w)$ has 5 numbers, and 80 is the number of classes we'd like to detect\n- You then select only few boxes based on:\n - Score-thresholding: throw away boxes that have detected a class with a score less than the threshold\n - Non-max suppression: Compute the Intersection over Union and avoid selecting overlapping boxes\n- This gives you YOLO's final output. ", "_____no_output_____" ], [ "<font color='blue'>\n \n**What you should remember**:\n \n- YOLO is a state-of-the-art object detection model that is fast and accurate\n- It runs an input image through a CNN, which outputs a 19x19x5x85 dimensional volume. \n- The encoding can be seen as a grid where each of the 19x19 cells contains information about 5 boxes.\n- You filter through all the boxes using non-max suppression. Specifically: \n - Score thresholding on the probability of detecting a class to keep only accurate (high probability) boxes\n - Intersection over Union (IoU) thresholding to eliminate overlapping boxes\n- Because training a YOLO model from randomly initialized weights is non-trivial and requires a large dataset as well as lot of computation, previously trained model parameters were used in this exercise. If you wish, you can also try fine-tuning the YOLO model with your own dataset, though this would be a fairly non-trivial exercise. ", "_____no_output_____" ], [ "**Congratulations!** You've come to the end of this assignment. \n\nHere's a quick recap of all you've accomplished.\n\nYou've: \n\n- Detected objects in a car detection dataset\n- Implemented non-max suppression to achieve better accuracy\n- Implemented intersection over union as a function of NMS\n- Created usable bounding box tensors from the model's predictions\n\nAmazing work! If you'd like to know more about the origins of these ideas, spend some time on the papers referenced below. ", "_____no_output_____" ], [ "<a name='5'></a>\n## 5 - References\n\nThe ideas presented in this notebook came primarily from the two YOLO papers. The implementation here also took significant inspiration and used many components from Allan Zelener's GitHub repository. The pre-trained weights used in this exercise came from the official YOLO website. \n- Joseph Redmon, Santosh Divvala, Ross Girshick, Ali Farhadi - [You Only Look Once: Unified, Real-Time Object Detection](https://arxiv.org/abs/1506.02640) (2015)\n- Joseph Redmon, Ali Farhadi - [YOLO9000: Better, Faster, Stronger](https://arxiv.org/abs/1612.08242) (2016)\n- Allan Zelener - [YAD2K: Yet Another Darknet 2 Keras](https://github.com/allanzelener/YAD2K)\n- The official YOLO website (https://pjreddie.com/darknet/yolo/) \n\n### Car detection dataset\n\n<a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"><img alt=\"Creative Commons License\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by/4.0/88x31.png\" /></a><br /><span xmlns:dct=\"http://purl.org/dc/terms/\" property=\"dct:title\">The Drive.ai Sample Dataset</span> (provided by drive.ai) is licensed under a <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Creative Commons Attribution 4.0 International License</a>. Thanks to Brody Huval, Chih Hu and Rahul Patel for providing this data. ", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ] ]

[ "ADSL" ]

[ "ADSL" ]

[ "ADSL" ]

[ [ [ "empty" ] ] ]

[ "empty" ]

[ [ "empty" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "##### Copyright 2018 The TensorFlow Authors.", "_____no_output_____" ] ], [ [ "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.", "_____no_output_____" ] ], [ [ "# Eager execution basics", "_____no_output_____" ], [ "<table class=\"tfo-notebook-buttons\" align=\"left\">\n <td>\n <a target=\"_blank\" href=\"https://www.tensorflow.org/2/tutorials/eager/eager_basics\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />View on TensorFlow.org</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/r2/tutorials/eager/eager_basics.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://github.com/tensorflow/docs/blob/master/site/en/r2/tutorials/eager/eager_basics.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n </td>\n</table>", "_____no_output_____" ], [ "This is an introductory TensorFlow tutorial shows how to:\n\n* Import the required package\n* Create and use tensors\n* Use GPU acceleration\n* Demonstrate `tf.data.Dataset`", "_____no_output_____" ] ], [ [ "!pip install tf-nightly-2.0-preview", "_____no_output_____" ] ], [ [ "## Import TensorFlow\n\nImport the `tensorflow` module to get started. [Eager execution](../../guide/eager.ipynb) is enabled by default.", "_____no_output_____" ] ], [ [ "import tensorflow as tf", "_____no_output_____" ] ], [ [ "## Tensors\n\nA Tensor is a multi-dimensional array. Similar to NumPy `ndarray` objects, `tf.Tensor` objects have a data type and a shape. Additionally, `tf.Tensor`s can reside in accelerator memory (like a GPU). TensorFlow offers a rich library of operations ([tf.add](https://www.tensorflow.org/api_docs/python/tf/add), [tf.matmul](https://www.tensorflow.org/api_docs/python/tf/matmul), [tf.linalg.inv](https://www.tensorflow.org/api_docs/python/tf/linalg/inv) etc.) that consume and produce `tf.Tensor`s. These operations automatically convert native Python types, for example:\n", "_____no_output_____" ] ], [ [ "print(tf.add(1, 2))\nprint(tf.add([1, 2], [3, 4]))\nprint(tf.square(5))\nprint(tf.reduce_sum([1, 2, 3]))\nprint(tf.io.encode_base64(\"hello world\"))\n\n# Operator overloading is also supported\nprint(tf.square(2) + tf.square(3))", "_____no_output_____" ] ], [ [ "Each `tf.Tensor` has a shape and a datatype:", "_____no_output_____" ] ], [ [ "x = tf.matmul([[1]], [[2, 3]])\nprint(x.shape)\nprint(x.dtype)", "_____no_output_____" ] ], [ [ "The most obvious differences between NumPy arrays and `tf.Tensor`s are:\n\n1. Tensors can be backed by accelerator memory (like GPU, TPU).\n2. Tensors are immutable.", "_____no_output_____" ], [ "### NumPy Compatibility\n\nConverting between a TensorFlow `tf.Tensor`s and a NumPy `ndarray` is easy:\n\n* TensorFlow operations automatically convert NumPy ndarrays to Tensors.\n* NumPy operations automatically convert Tensors to NumPy ndarrays.\n\nTensors are explicitly converted to NumPy ndarrays using their `.numpy()` method. These conversions are typically cheap since the array and `tf.Tensor` share the underlying memory representation, if possible. However, sharing the underlying representation isn't always possible since the `tf.Tensor` may be hosted in GPU memory while NumPy arrays are always backed by host memory, and the conversion involves a copy from GPU to host memory.", "_____no_output_____" ] ], [ [ "import numpy as np\n\nndarray = np.ones([3, 3])\n\nprint(\"TensorFlow operations convert numpy arrays to Tensors automatically\")\ntensor = tf.multiply(ndarray, 42)\nprint(tensor)\n\n\nprint(\"And NumPy operations convert Tensors to numpy arrays automatically\")\nprint(np.add(tensor, 1))\n\nprint(\"The .numpy() method explicitly converts a Tensor to a numpy array\")\nprint(tensor.numpy())", "_____no_output_____" ] ], [ [ "## GPU acceleration\n\nMany TensorFlow operations are accelerated using the GPU for computation. Without any annotations, TensorFlow automatically decides whether to use the GPU or CPU for an operation—copying the tensor between CPU and GPU memory, if necessary. Tensors produced by an operation are typically backed by the memory of the device on which the operation executed, for example:", "_____no_output_____" ] ], [ [ "x = tf.random.uniform([3, 3])\n\nprint(\"Is there a GPU available: \"),\nprint(tf.test.is_gpu_available())\n\nprint(\"Is the Tensor on GPU #0: \"),\nprint(x.device.endswith('GPU:0'))", "_____no_output_____" ] ], [ [ "### Device Names\n\nThe `Tensor.device` property provides a fully qualified string name of the device hosting the contents of the tensor. This name encodes many details, such as an identifier of the network address of the host on which this program is executing and the device within that host. This is required for distributed execution of a TensorFlow program. The string ends with `GPU:<N>` if the tensor is placed on the `N`-th GPU on the host.", "_____no_output_____" ], [ "\n\n### Explicit Device Placement\n\nIn TensorFlow, *placement* refers to how individual operations are assigned (placed on) a device for execution. As mentioned, when there is no explicit guidance provided, TensorFlow automatically decides which device to execute an operation and copies tensors to that device, if needed. However, TensorFlow operations can be explicitly placed on specific devices using the `tf.device` context manager, for example:", "_____no_output_____" ] ], [ [ "import time\n\ndef time_matmul(x):\n start = time.time()\n for loop in range(10):\n tf.matmul(x, x)\n\n result = time.time()-start\n \n print(\"10 loops: {:0.2f}ms\".format(1000*result))\n\n# Force execution on CPU\nprint(\"On CPU:\")\nwith tf.device(\"CPU:0\"):\n x = tf.random.uniform([1000, 1000])\n assert x.device.endswith(\"CPU:0\")\n time_matmul(x)\n\n# Force execution on GPU #0 if available\nif tf.test.is_gpu_available():\n with tf.device(\"GPU:0\"): # Or GPU:1 for the 2nd GPU, GPU:2 for the 3rd etc.\n x = tf.random.uniform([1000, 1000])\n assert x.device.endswith(\"GPU:0\")\n time_matmul(x)", "_____no_output_____" ] ], [ [ "## Datasets\n\nThis section uses the [`tf.data.Dataset` API](https://www.tensorflow.org/guide/datasets) to build a pipeline for feeding data to your model. The `tf.data.Dataset` API is used to build performant, complex input pipelines from simple, re-usable pieces that will feed your model's training or evaluation loops.", "_____no_output_____" ], [ "### Create a source `Dataset`\n\nCreate a *source* dataset using one of the factory functions like [`Dataset.from_tensors`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#from_tensors), [`Dataset.from_tensor_slices`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#from_tensor_slices), or using objects that read from files like [`TextLineDataset`](https://www.tensorflow.org/api_docs/python/tf/data/TextLineDataset) or [`TFRecordDataset`](https://www.tensorflow.org/api_docs/python/tf/data/TFRecordDataset). See the [TensorFlow Dataset guide](https://www.tensorflow.org/guide/datasets#reading_input_data) for more information.", "_____no_output_____" ] ], [ [ "ds_tensors = tf.data.Dataset.from_tensor_slices([1, 2, 3, 4, 5, 6])\n\n# Create a CSV file\nimport tempfile\n_, filename = tempfile.mkstemp()\n\nwith open(filename, 'w') as f:\n f.write(\"\"\"Line 1\nLine 2\nLine 3\n \"\"\")\n\nds_file = tf.data.TextLineDataset(filename)", "_____no_output_____" ] ], [ [ "### Apply transformations\n\nUse the transformations functions like [`map`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#map), [`batch`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#batch), and [`shuffle`](https://www.tensorflow.org/api_docs/python/tf/data/Dataset#shuffle) to apply transformations to dataset records.", "_____no_output_____" ] ], [ [ "ds_tensors = ds_tensors.map(tf.square).shuffle(2).batch(2)\n\nds_file = ds_file.batch(2)", "_____no_output_____" ] ], [ [ "### Iterate\n\n`tf.data.Dataset` objects support iteration to loop over records:", "_____no_output_____" ] ], [ [ "print('Elements of ds_tensors:')\nfor x in ds_tensors:\n print(x)\n\nprint('\\nElements in ds_file:')\nfor x in ds_file:\n print(x)", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Header starts here.\nfrom sympy.physics.units import *\nfrom sympy import *\n\n# Rounding:\nimport decimal\nfrom decimal import Decimal as DX\nfrom copy import deepcopy\ndef iso_round(obj, pv, rounding=decimal.ROUND_HALF_EVEN):\n import sympy\n \"\"\"\n Rounding acc. to DIN EN ISO 80000-1:2013-08\n place value = Rundestellenwert\n \"\"\"\n assert pv in set([\n # place value # round to:\n 1, # 1\n 0.1, # 1st digit after decimal\n 0.01, # 2nd\n 0.001, # 3rd\n 0.0001, # 4th\n 0.00001, # 5th\n 0.000001, # 6th\n 0.0000001, # 7th\n 0.00000001, # 8th\n 0.000000001, # 9th\n 0.0000000001, # 10th\n ])\n objc = deepcopy(obj)\n try:\n tmp = DX(str(float(objc)))\n objc = tmp.quantize(DX(str(pv)), rounding=rounding)\n except:\n for i in range(len(objc)):\n tmp = DX(str(float(objc[i])))\n objc[i] = tmp.quantize(DX(str(pv)), rounding=rounding)\n return objc\n\n# LateX:\nkwargs = {}\nkwargs[\"mat_str\"] = \"bmatrix\"\nkwargs[\"mat_delim\"] = \"\"\n\n# kwargs[\"symbol_names\"] = {FB: \"F^{\\mathsf B}\", }\n\n# Units:\n(k, M, G ) = ( 10**3, 10**6, 10**9 )\n(mm, cm) = ( m/1000, m/100 )\nNewton = kg*m/s**2\nPa = Newton/m**2\nMPa = M*Pa\nGPa = G*Pa\nkN = k*Newton\ndeg = pi/180\n\nhalf = S(1)/2\n\n# Header ends here.\n#\n# https://colab.research.google.com/github/kassbohm/wb-snippets/blob/master/ipynb/TEM_10/ESA/a1_cc.ipynb\n\nF,l = var(\"F,l\")\nR = 3*F/2\nlu = l/sqrt(3)\n\nAh,Av,Bh,Bv,Ch,Cv = var(\"Ah,Av,Bh,Bv,Ch,Cv\")\n\ne1 = Eq(Ah + Bh + F)\ne2 = Eq(Av + Bv - R)\ne3 = Eq(Bv*l - Bh*l - F*l/2 - R*7/18*l)\n\ne4 = Eq(Ch - Bh)\ne5 = Eq(Cv - F - Bv)\ne6 = Eq(F*lu/2 + Bv*lu + Bh*l)\n\neqs = [e1,e2,e3,e4,e5,e6]\nunknowns = [Ah,Av,Bh,Bv,Ch,Cv]\n\n\npprint(\"\\nEquations:\")\nfor e in eqs:\n pprint(e)\n pprint(\"\\n\")\n\n\n# Alternative Solution (also correct):\n# Ah,Av,Bh,Bv,Gh,Gv = var(\"Ah,Av,Bh,Bv,Gh,Gv\")\n#\n# e1 = Eq(Av + Gv - R)\n# e2 = Eq(Ah + F - Gh)\n# e3 = Eq(F/2 + 7*R/18 - Gv - Gh)\n# e4 = Eq(-Gv -F + Bv)\n# e5 = Eq(Gh - Bh)\n# e6 = Eq(Gh - sqrt(3)*F/6 - Gv/sqrt(3))\n#\n# eqs = [e1,e2,e3,e4,e5,e6]\n# unknowns = [Ah,Av,Bh,Bv,Gh,Gv]\n\nsol = solve(eqs,unknowns)\n\npprint(\"\\nReactions:\")\npprint(sol)\n\npprint(\"\\nReactions / F (rounded to 0.01):\")\nfor v in sorted(sol,key=default_sort_key):\n pprint(\"\\n\\n\")\n s = sol[v]\n tmp = (s/F)\n tmp = tmp.simplify()\n # pprint(tmp)\n pprint([v, tmp, iso_round(tmp,0.01)])\n\n# Reactions / F:\n#\n# ⎡ 43 19⋅√3 ⎤\n# ⎢Ah, - ── + ─────, -0.42⎥\n# ⎣ 24 24 ⎦\n#\n#\n# ⎡ 3 19⋅√3 ⎤\n# ⎢Av, - ─ + ─────, 1.0⎥\n# ⎣ 8 24 ⎦\n#\n#\n# ⎡ 19⋅√3 19 ⎤\n# ⎢Bh, - ───── + ──, -0.58⎥\n# ⎣ 24 24 ⎦\n#\n#\n# ⎡ 19⋅√3 15 ⎤\n# ⎢Bv, - ───── + ──, 0.5⎥\n# ⎣ 24 8 ⎦\n#\n#\n# ⎡ 19⋅√3 19 ⎤\n# ⎢Ch, - ───── + ──, -0.58⎥\n# ⎣ 24 24 ⎦\n#\n#\n# ⎡ 19⋅√3 23 ⎤\n# ⎢Cv, - ───── + ──, 1.5⎥\n# ⎣ 24 8 ⎦\n", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code" ] ]

[ "CC-BY-4.0" ]

[ "CC-BY-4.0" ]

[ "CC-BY-4.0" ]

[ [ [ "# Tests and Exceptions\n\nIn this lesson we will look at how to make your code more reliable by writing tests. Tests when used cleverly can give you a lot of confidence in your code and therefore your results!\n\nLets start with our (broken) square function from the last lesson:", "_____no_output_____" ], [ "Tests can take many forms, they can compare your code against known results i.e. ones in a published paper, or they can just test that the result of some function returns the type of object you expect or even just check that your code results always stays the same, so you know if something breaks.\n\nA simple test for our square function we defined above might look like:", "_____no_output_____" ], [ "\n<section class=\"callout panel panel-warning\">\n<div class=\"panel-heading\">\n<h2><span class=\"fa fa-thumb-tack\"></span> The `assert` statement</h2>\n</div>\n\n\n<div class=\"panel-body\">\n\n<p>As we will see later, the way to make a test fail is to raise an error. Therefore the <code>assert</code> statement in Python is a useful shortcut when writing tests.</p>\n<p>The <code>assert</code> statement will raise an error if a condition is not satisfied. The general form of the assert statement is:</p>\n<div class=\"codehilite\"><pre><span></span><span class=\"k\">assert</span> <span class=\"n\">condition</span><span class=\"p\">,</span> <span class=\"s2\">&quot;message&quot;</span>\n</pre></div>\n\n\n<p>i.e.</p>\n<div class=\"codehilite\"><pre><span></span><span class=\"k\">assert</span> <span class=\"mi\">5</span> <span class=\"o\">==</span> <span class=\"mi\">6</span><span class=\"p\">,</span> <span class=\"s2\">&quot;Five is not equal to six&quot;</span>\n</pre></div>\n\n</div>\n\n</section>\n", "_____no_output_____" ], [ "We can run our test function the same way that we run any other function. Although this dosent scale very well to thousands of tests!", "_____no_output_____" ], [ "\n<section class=\"challange panel panel-success\">\n<div class=\"panel-heading\">\n<h2><span class=\"fa fa-pencil\"></span> Writing Tests</h2>\n</div>\n\n\n<div class=\"panel-body\">\n\n<p>The following function has bugs in it. Write some tests below the function to find all the bugs.</p>\n\n</div>\n\n</section>\n", "_____no_output_____" ], [ "## Running Tests Automatically with pytest\n\nOnce you have a few test functions written, you will probably start getting bored with typing out their names and running them one-by-one. There are a few different modules to help you write and run tests. The one we will be using is called [`pytest`](https://docs.pytest.org/en/latest/). \n\nFor the next section of this session we will be using the two Python (`.py`) files named `askdl.py` and `lsadkj.py`.", "_____no_output_____" ] ] ]

[ "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ] ]

[ "CC-BY-3.0" ]

[ "CC-BY-3.0" ]

[ "CC-BY-3.0" ]

[ [ [ "# Introduction to programming for Geoscientists through Python\n### [Gerard Gorman](http://www.imperial.ac.uk/people/g.gorman), [Nicolas Barral](http://www.imperial.ac.uk/people/n.barral)\n# Lecture 6: Files, strings, and dictionaries", "_____no_output_____" ], [ "Learning objectives: You will learn how to:\n\n* Read data in from a file\n* Parse strings to extract specific data of interest.\n* Use dictionaries to index data using any type of key.", "_____no_output_____" ] ], [ [ "from client.api.notebook import Notebook\nfrom client.api import assignment\nfrom client.utils import auth\n\nargs = assignment.Settings(server='okpyic.azurewebsites.net')\nok = Notebook('./lecture6.ok', args)", "=====================================================================\nAssignment: Lecture 6\nOK, version v1.13.11\n=====================================================================\n\n" ], [ "var1 = 4\nvar2 = 3\nvar3 = 3\n\ndef funct1():\n return 0\n\ndef funct2():\n return 0", "_____no_output_____" ], [ "ok.grade('lect6-q0')", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nRunning tests\n\n---------------------------------------------------------------------\nTest summary\n Passed: 5\n Failed: 0\n[ooooooooook] 100.0% passed\n\n" ] ], [ [ "## Reading data from a plain text file\nWe can read text from a [text file](http://en.wikipedia.org/wiki/Text_file) into strings in a program. This is a common (and simple) way for a program to get input data. The basic recipe is:", "_____no_output_____" ] ], [ [ "# Open text file\ninfile = open(\"myfile.dat\", \"r\")\n\n# Read next line:\nline = infile.readline()\n\n# Read the lines in a loop one by one:\nfor line in infile:\n <process line>\n\n# Load all lines into a list of strings:\nlines = infile.readlines()\nfor line in lines:\n <process line>", "_____no_output_____" ] ], [ [ "Let's look at the file [data1.txt](https://raw.githubusercontent.com/ggorman/Introduction-to-programming-for-geoscientists/master/notebook/data/data1.txt) (all of the data files in this lecture are stored in the sub-folder *data/* of this notebook library). The files has a column of numbers:", "_____no_output_____" ] ], [ [ "21.8\n18.1\n19\n23\n26\n17.8", "_____no_output_____" ] ], [ [ "The goal is to read this file and calculate the mean:", "_____no_output_____" ] ], [ [ "# Open data file\ninfile = open(\"data/data1.txt\", \"r\")\n\n# Initialise values\nmean = 0\nn=0\n\n# Loop to perform sum\nfor number in infile:\n number = float(number)\n mean = mean + number\n n += 1\n \n# It is good practice to close a file when you are finished. \ninfile.close()\n\n# Calculate the mean.\nmean = mean/n\nprint(mean)", "20.95\n" ] ], [ [ "Let's make this example more interesting. There is a **lot** of data out there for you to discover all kinds of interesting facts - you just need to be interested in learning a little analysis. For this case I have downloaded tidal gauge data for the port of Avonmouth from the [BODC](http://www.bodc.ac.uk/). If you look at the header of file [data/2012AVO.txt](https://raw.githubusercontent.com/ggorman/Introduction-to-programming-for-geoscientists/master/notebook/data/2012AVO.txt) you will see the [metadata](http://en.wikipedia.org/wiki/Metadata):", "_____no_output_____" ] ], [ [ "Port: P060\nSite: Avonmouth\nLatitude: 51.51089\nLongitude: -2.71497\nStart Date: 01JAN2012-00.00.00\nEnd Date: 30APR2012-23.45.00\nContributor: National Oceanography Centre, Liverpool\nDatum information: The data refer to Admiralty Chart Datum (ACD)\nParameter code: ASLVTD02 = Surface elevation (unspecified datum) of the water body by fixed in-situ pressure sensor", "_____no_output_____" ] ], [ [ "Let's read the column ASLVTD02 (the surface elevation) and plot it:", "_____no_output_____" ] ], [ [ "from pylab import *\n\ntide_file = open(\"data/2012AVO.txt\", \"r\")\n\n# We know from inspecting the file that the first 11 lines are just\n# header information so lets just skip those lines.\nfor i in range(11):\n line = tide_file.readline()\n\n# Initialise an empty list to store the elevation\nelevation = []\ndays = []\n\n# Now we start reading the interesting data\nn=0\nwhile True: # This will keep looping until we break out.\n # Here we use a try/except block to try to read the data as normal\n # and to break out if unsuccessful - ie when we reach the end of the file. \n try:\n # Read the next line\n line = tide_file.readline()\n \n # Split this line into words. \n words = line.split()\n \n # If we do not have 5 words then it must be blank lines at the end of the file.\n if len(words)!=5:\n break\n except:\n # If we failed to read a line then we must have got to the end.\n break\n \n n+=1 # Count number of data points\n\n try:\n # The elevation data is on the 4th column. However, the BODC\n # appends a \"M\" when a value is improbable and an \"N\" when\n # data is missing (maybe a ship dumped into it during rough weather!)\n # Therefore, we put this conversion from a string into a float in a \n # try/except block.\n level = float(words[3])\n elevation.append(level)\n \n # There is a measurement every quarter hour.\n days.append(n*0.25/24) \n except:\n continue\n \n# For plotting lets convert the list to a NumPy array.\nelevation = array(elevation)\ndays = array(days)\n\nplot(days, elevation)\nxlabel(\"Days\")\nylabel(\"Elevation (meters)\")\nshow()", "_____no_output_____" ] ], [ [ "Quiz time:\n\n* What tidal constituents can you identify by looking at this plot?\n* Is this primarily a diurnal or semi-diurnal tidal region? (hint - change the x-axis range on the plot above).\n\nYou will notice in the above example that we used the *split()* string member function. This is a very useful function for grabbing individual words on a line. When called without any arguments it assumes that the [delimiter](http://en.wikipedia.org/wiki/Delimiter) is a blank space. However, you can use this to split a string with any delimiter, *e.g.*, *line.split(';')*, *line.split(':')*.", "_____no_output_____" ], [ "## <span style=\"color:blue\">Exercise 6.1: Read a two-column data file</span>\nThe file [data/xy.dat](https://raw.githubusercontent.com/ggorman/Introduction-to-programming-for-geoscientists/master/notebook/data/xy.dat) contains two columns of numbers, corresponding to *x* and *y* coordinates on a curve. The start of the file looks like this:\n\n-1.0000 -0.0000</br>\n-0.9933 -0.0087</br>\n-0.9867 -0.0179</br>\n-0.9800 -0.0274</br>\n-0.9733 -0.0374</br>\n\nMake a program that reads the first column into a list `xlist_61` and the second column into a list `ylist_61`. Then convert the lists to arrays named `xarray_61` and `yarray_61`, and plot the curve. Store the maximum and minimum y coordinates in two variables named `ymin_61` and `ymax_61`. (Hint: Read the file line by line, split each line into words, convert to float, and append to `xlist_61` and `ylist_61`.)</br>", "_____no_output_____" ] ], [ [ "# Open data file\ninfile = open(\"data/xy.dat\", \"r\") # \"r\" is for read\n\n# Initialise empty lists\nxlist_61 = []\nylist_61 = []\n\n# Loop through infile and write to x and y lists\nfor line in infile:\n line = line.split() # convert to list by dropping spaces\n xlist_61.append(float(line[0])) # take 0th element and covert to float\n ylist_61.append(float(line[1])) # take 1st element and covert to float\n\n\n# Close the filehandle\ninfile.close()\n\nxarray_61 = np.array(xlist_61)\nyarray_61 = np.array(ylist_61)\n\nymin_61 = yarray_61.min()\nymax_61 = yarray_61.max()", "_____no_output_____" ], [ "grade = ok.grade('lect6-q1')\nprint(\"===\", grade, \"===\")", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nRunning tests\n\n---------------------------------------------------------------------\nTest summary\n Passed: 9\n Failed: 0\n[ooooooooook] 100.0% passed\n\n=== {'passed': 9, 'failed': 0, 'locked': 0} ===\n" ] ], [ [ "## <span style=\"color:blue\">Exercise 6.2: Read a data file</span>\nThe files [data/density_water.dat](https://raw.githubusercontent.com/ggorman/Introduction-to-programming-for-geoscientists/master/notebook/data/density_water.dat) and [data/density_air.dat](https://raw.githubusercontent.com/ggorman/Introduction-to-programming-for-geoscientists/master/notebook/data/density_air.dat) contain data about the density of water and air (respectively) for different temperatures. The data files have some comment lines starting with # and some lines are blank. The rest of the lines contain density data: the temperature in the first column and the corresponding density in the second column. The goal of this exercise is to read the data in such a file, discard commented or blank lines, and plot the density versus the temperature as distinct (small) circles for each data point. Write a function `readTempDenFile` that takes a filename as argument and returns two lists containing respectively the temperature and the density. Call this function on both files, and store the temperature and density in lists called `temp_air_list`, `dens_air_list`, `temp_water_list` and `dens_water_list`.", "_____no_output_____" ] ], [ [ "def readTempDenFile(filename):\n infile = open(filename, \"r\")\n temp = []\n dens = []\n for line in infile:\n try:\n t, d = line.split()\n t = float(t)\n d = float(d)\n except:\n continue\n temp.append(t) # N.B. we're now filling out temp and dens lists\n dens.append(d)\n infile.close()\n plot(array(temp), array(dens))\n xlabel(\"Temperature (C)\")\n ylabel(\"Density (kg/m^3)\")\n show()\n return temp,dens\n\n# run function\ntemp_air_list, dens_air_list = readTempDenFile(\"data/density_air.dat\")\ntemp_water_list, dens_water_list = readTempDenFile(\"data/density_water.dat\")", "_____no_output_____" ], [ "ok.grade(\"lect6-q2\")", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nRunning tests\n\n" ] ], [ [ "## <span style=\"color:blue\">Exercise 6.3: Read acceleration data and find velocities</span>\nA file [data/acc.dat](https://raw.githubusercontent.com/ggorman/Introduction-to-programming-for-geoscientists/master/notebook/data/acc.dat) contains measurements $a_0, a_1, \\ldots, a_{n-1}$ of the acceleration of an object moving along a straight line. The measurement $a_k$ is taken at time point $t_k = k\\Delta t$, where $\\Delta t$ is the time spacing between the measurements. The purpose of the exercise is to load the acceleration data into a program and compute the velocity $v(t)$ of the object at some time $t$.\n\nIn general, the acceleration $a(t)$ is related to the velocity $v(t)$ through $v^\\prime(t) = a(t)$. This means that\n\n$$\nv(t) = v(0) + \\int_0^t{a(\\tau)d\\tau}\n$$\n\nIf $a(t)$ is only known at some discrete, equally spaced points in time, $a_0, \\ldots, a_{n-1}$ (which is the case in this exercise), we must compute the integral above numerically, for example by the Trapezoidal rule:\n\n$$\nv(t_k) \\approx v(0) + \\Delta t \\left(\\frac{1}{2}a_0 + \\frac{1}{2}a_k + \\sum_{i=1}^{k-1}a_i \\right), \\ \\ 1 \\leq k \\leq n-1. \n$$\n\nWe assume $v(0) = 0$ so that also $v_0 = 0$.\nRead the values $a_0, \\ldots, a_{n-1}$ from file into an array `acc_array_63` and plot the acceleration versus time for $\\Delta_t = 0.5$. The time should be stored in an array named `time_array_63`.\n\nThen write a function `compute_velocity(dt, k, a)` that takes as arguments a time interval $\\Delta_t$ `dt`, an index `k` and a list of accelerations `a`, uses the Trapezoidal rule to compute one $v(t_k)$ value and return this value. Experiment with different values of $\\Delta t$ and $k$.", "_____no_output_____" ] ], [ [ "dt = 0.5\n\n# read in acceleration\ninfile = open(\"data/acc.dat\", \"r\")\nalist = []\nfor line in infile:\n alist.append(float(line))\ninfile.close()\nacc_array_63 = array(alist)\ntime_array_63 = array([e*dt for e in range(len(alist))]) # time is specified by dt and the number of elements in acc.dat\n\n#print(time_array_63, acc_array_63)\n\n# plot\nplot(time_array_63, acc_array_63)\nxlabel(\"Time\")\nylabel(\"Acceleration\")\nshow()\n\ndef compute_velocity(dt, k, alist):\n if not (1 <= k <= (len(alist) - 1)):\n raise ValueError\n return dt*(.5*alist[0] + .5*alist[k] + sum(alist[:k]))\n\ndt = 2\nk = 4\nprint(compute_velocity(2, 4, alist))\nprint(compute_velocity(3, 5, alist))\nprint(compute_velocity(12, 21, alist))", "_____no_output_____" ], [ "ok.grade('lect6-q3')", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nRunning tests\n\n---------------------------------------------------------------------\nTest summary\n Passed: 15\n Failed: 0\n[ooooooooook] 100.0% passed\n\n" ] ], [ [ "## Python dictionaries\nSuppose we need to store the temperatures in Oslo, London and Paris. The Python list solution might look like:", "_____no_output_____" ] ], [ [ "temps = [13, 15.4, 17.5]\n# temps[0]: Oslo\n# temps[1]: London\n# temps[2]: Paris", "_____no_output_____" ] ], [ [ "In this case we need to remember the mapping between the index and the city name. It would be easier to specify name of city to get the temperature. Containers such as lists and arrays use a continuous series of integers to index elements. However, for many applications such an integer index is not useful.\n\n**Dictionaries** are containers where any Python object can be used\nas an index. Let's rewrite the previous example using a Python dictionary:", "_____no_output_____" ] ], [ [ "temps = {\"Oslo\": 13, \"London\": 15.4, \"Paris\": 17.5}\nprint(\"The temperature in London is\", temps[\"London\"])", "The temperature in London is 15.4\n" ] ], [ [ "Add a new element to a dictionary:", "_____no_output_____" ] ], [ [ "temps[\"Madrid\"] = 26.0\nprint(temps)", "{'Oslo': 13, 'London': 15.4, 'Paris': 17.5, 'Madrid': 26.0}\n" ] ], [ [ "Loop (iterate) over a dictionary:", "_____no_output_____" ] ], [ [ "for city in temps:\n print(\"The temperature in %s is %g\" % (city, temps[city]))", "The temperature in Oslo is 13\nThe temperature in London is 15.4\nThe temperature in Paris is 17.5\nThe temperature in Madrid is 26\n" ] ], [ [ "The index in a dictionary is called the **key**. A dictionary is said to hold key–value pairs. So in general:", "_____no_output_____" ] ], [ [ "for key in dictionary:\n value = dictionary[key]\n print(value)", "_____no_output_____" ] ], [ [ "Does the dictionary have a particular key (*i.e.* a particular data entry)?", "_____no_output_____" ] ], [ [ "if \"Berlin\" in temps:\n print(\"We have Berlin and its temperature is \", temps[\"Berlin\"])\nelse:\n print(\"I don't know Berlin' termperature.\")", "I don't know Berlin' termperature.\n" ], [ "print(\"Oslo\" in temps) # i.e. standard boolean expression", "True\n" ] ], [ [ "The keys and values can be reached as lists:", "_____no_output_____" ] ], [ [ "print(\"Keys = \", temps.keys())\nprint(\"Values = \", temps.values())", "Keys = dict_keys(['Oslo', 'London', 'Paris', 'Madrid'])\nValues = dict_values([13, 15.4, 17.5, 26.0])\n" ] ], [ [ "Note that the sequence of keys is **arbitrary**! Never rely on it, if you need a specific order of the keys then you should explicitly sort:", "_____no_output_____" ] ], [ [ "for key in sorted(temps):\n value = temps[key]\n print(key, value)", "London 15.4\nMadrid 26.0\nOslo 13\nParis 17.5\n" ] ], [ [ "Remove Oslo key:value:", "_____no_output_____" ] ], [ [ "del temps[\"Oslo\"] # remove Oslo key w/value\nprint(temps, len(temps))", "{'London': 15.4, 'Paris': 17.5, 'Madrid': 26.0} 3\n" ] ], [ [ "Similarly to what we saw for arrays, two variables can refer to the same dictionary:", "_____no_output_____" ] ], [ [ "t1 = temps\nt1[\"Stockholm\"] = 10.0\nprint(temps)", "{'London': 15.4, 'Paris': 17.5, 'Madrid': 26.0, 'Stockholm': 10.0}\n" ] ], [ [ "So we can see that while we modified *t1*, the *temps* dictionary was also changed.", "_____no_output_____" ], [ "Let's look at a simple example of reading the same data from a file and putting it into a dictionary. We will be reading the file *data/deg2.dat*.", "_____no_output_____" ] ], [ [ "infile = open(\"data/deg2.dat\", \"r\")\n# Start with empty dictionary\ntemps = {} \nfor line in infile:\n # If you examine the file you will see a ':' after the city name,\n # so let's use this as the delimiter for splitting the line.\n city, temp = line.split(\":\") \n temps[city] = float(temp)\ninfile.close()\nprint(temps)", "{'Oslo': 21.8, 'London': 18.1, 'Berlin': 19.0, 'Paris': 23.0, 'Rome': 26.0}\n" ] ], [ [ "## <span style=\"color:blue\">Exercise 6.4: Make a dictionary from a table</span>\nThe file [data/constants.txt](https://raw.githubusercontent.com/ggorman/Introduction-to-programming-for-geoscientists/master/notebook/data/constants.txt) contains a table of the values and the dimensions of some fundamental constants from physics. We want to load this table into a dictionary *constants*, where the keys are the names of the constants. For example, *constants['gravitational constant']* holds the value of the gravitational constant (6.67259 $\\times$ 10$^{-11}$) in Newton's law of gravitation. Make a function `read_constants(file_path)` that that reads and interprets the text in the file passed as argument, and thereafter returns the dictionary.", "_____no_output_____" ] ], [ [ "def read_constants(file_path):\n infile = open(file_path, \"r\")\n constants = {} # An empty dictionary to store the constants that are read in from the file\n infile.readline(); infile.readline() # Skip the first two lines of the file, since these just contain the column names and the separator.\n for line in infile:\n words = line.split() # Split each line up into individual words\n dimension = words.pop() # pop is a list operation that removes the last element from a list and returns it\n value = float(words.pop()) # Again, use pop to obtain the constant itself.\n name = \" \".join(words) # After the two 'pop' operations above, the words remaining in the 'words' list must be the name of the constant. Join the individual words together, with spaces inbetween, using .join.\n constants[name] = value # Create a new key-value pair in the dictionary\n return constants\n\nprint(read_constants('data/constants.txt'))", "{'speed of light': 299792458.0, 'gravitational constant': 6.67259e-11, 'Planck constant': 6.6260755e-34, 'elementary charge': 1.60217733e-19, 'Avogadro number': 6.0221367e+23, 'Boltzmann constant': 1.380658e-23, 'electron mass': 9.1093897e-31, 'proton mass': 1.6726231e-27}\n" ], [ "ok.grade('lect6-q4')", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nRunning tests\n\n---------------------------------------------------------------------\nTest summary\n Passed: 1\n Failed: 0\n[ooooooooook] 100.0% passed\n\n" ] ], [ [ "## <span style=\"color:blue\">Exercise 6.5: Explore syntax differences: lists vs. dictionaries</span>\nConsider this code:", "_____no_output_____" ] ], [ [ "t1 = {}\nt1[0] = -5\nt1[1] = 10.5", "_____no_output_____" ] ], [ [ "Explain why the lines above work fine while the ones below do not:", "_____no_output_____" ] ], [ [ "t2 = []\n#t2[0] = -5\n#t2[1] = 10.5", "_____no_output_____" ] ], [ [ "What must be done in the last code snippet to make it work properly?", "_____no_output_____" ], [ "## <span style=\"color:blue\">Exercise 6.6: Compute the area of a triangle</span>\nAn arbitrary triangle can be described by the coordinates of its three vertices: $(x_1, y_1), (x_2, y_2), (x_3, y_3)$, numbered in a counterclockwise direction. The area of the triangle is given by the formula:\n\n$A = \\frac{1}{2}|x_2y_3 - x_3y_2 - x_1y_3 + x_3y_1 + x_1y_2 - x_2y_1|.$\n\nWrite a function `triangle_area(vertices)` that returns the area of a triangle whose vertices are specified by the argument vertices, which is a nested list of the vertex coordinates. For example, vertices can be [[0,0], [1,0], [0,2]] if the three corners of the triangle have coordinates (0, 0), (1, 0), and (0, 2).\n\nThen, assume that the vertices of the triangle are stored in a dictionary and not a list. The keys in the dictionary correspond to the vertex number (1, 2, or 3) while the values are 2-tuples with the x and y coordinates of the vertex. For example, in a triangle with vertices (0, 0), (1, 0), and (0, 2) the vertices argument becomes:", "_____no_output_____" ] ], [ [ "def triangle_area(vertices):\n # nb. vertices = {v1: (x,y)}\n x2y3 = vertices[2][0] * vertices[3][1]\n x3y2 = vertices[3][0] * vertices[2][1]\n x1y3 = vertices[1][0] * vertices[3][1]\n x3y1 = vertices[3][0] * vertices[1][1]\n x1y2 = vertices[1][0] * vertices[2][1]\n x2y1 = vertices[2][0] * vertices[1][1]\n return .5*(x2y3 - x3y2 - x1y3 + x3y1 + x1y2 - x2y1)\n\nprint(triangle_area({1: (0,0), 2: (1,0), 3: (0,1)}))", "0.5\n" ], [ "ok.grade('lect6-q6')", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nRunning tests\n\n---------------------------------------------------------------------\nTest summary\n Passed: 3\n Failed: 0\n[ooooooooook] 100.0% passed\n\n" ] ], [ [ "## String manipulation\nText in Python is represented as **strings**. Programming with strings is therefore the key to interpret text in files and construct new text (*i.e.* **parsing**). First we show some common string operations and then we apply them to real examples. Our sample string used for illustration is:", "_____no_output_____" ] ], [ [ "s = \"Berlin: 18.4 C at 4 pm\"", "_____no_output_____" ] ], [ [ "Strings behave much like lists/tuples - they are simply a sequence of characters:", "_____no_output_____" ] ], [ [ "print(\"s[0] = \", s[0])\nprint(\"s[1] = \", s[1])", "s[0] = B\ns[1] = e\n" ] ], [ [ "Substrings are just slices of lists and arrays:", "_____no_output_____" ] ], [ [ "# from index 8 to the end of the string\nprint(s[8:])", "18.4 C at 4 pm\n" ], [ "# index 8, 9, 10 and 11 (not 12!)\nprint(s[8:12])", "18.4\n" ], [ "# from index 8 to 8 from the end of the string\nprint(s[8:-8])", "18.4 C\n" ] ], [ [ "You can also find the start of a substring:", "_____no_output_____" ] ], [ [ "# where does \"Berlin\" start?\nprint(s.find(\"Berlin\"))", "0\n" ], [ "print(s.find(\"pm\"))", "20\n" ], [ "print (s.find(\"Oslo\"))", "-1\n" ] ], [ [ "In this last example, Oslo does not exist in the list so the return value is -1.", "_____no_output_____" ], [ "We can also check if a substring is contained in a string:", "_____no_output_____" ] ], [ [ "print (\"Berlin\" in s)", "True\n" ], [ "print (\"Oslo\" in s)", "False\n" ], [ "if \"C\" in s:\n print(\"C found\")\nelse:\n print(\"C not found\")", "C found\n" ] ], [ [ "### Search and replace\nStrings also support substituting a substring by another string. In general this looks like *s.replace(s1, s2)*, which replaces string *s1* in *s* by string *s2*, *e.g.*:", "_____no_output_____" ] ], [ [ "s = s.replace(\" \", \"_\")\nprint(s)", "Berlin:_18.4_C_at_4_pm\n" ], [ "s = s.replace(\"Berlin\", \"Bonn\")\nprint(s)", "Bonn:_18.4_C_at_4_pm\n" ], [ "# Replace the text before the first colon by 'London'\ns = s.replace(s[:s.find(\":\")], \"London\")\nprint(s)", "London:_18.4_C_at_4_pm\n" ] ], [ [ "Notice that in all these examples we assign the new result back to *s*. One of the reasons we are doing this is strings are actually constant (*i.e* immutable) and therefore cannot be modified *inplace*. We **cannot** write for example:", "_____no_output_____" ] ], [ [ "s[18] = '5'\nTypeError: \"str\" object does not support item assignment", "_____no_output_____" ] ], [ [ "We also encountered examples above where we used the split function to break up a line into separate substrings for a given separator (where a space is the default delimiter). Sometimes we want to split a string into lines - *i.e.* the delimiter is the [carriage return](http://en.wikipedia.org/wiki/Carriage_return). This can be surprisingly tricky because different computing platforms (*e.g.* Windows, Linux, Mac) use different characters to represent a carriage return. For example, Unix uses '\\n'. Luckly Python provides a *cross platform* way of doing this so regardless of what platform created the data file, or what platform you are running Python on, it will do the *right thing*: ", "_____no_output_____" ] ], [ [ "t = \"1st line\\n2nd line\\n3rd line\"\nprint (\"\"\"original t =\n\"\"\", t)", "original t =\n 1st line\n2nd line\n3rd line\n" ], [ "# This works here but will give you problems if you are switching\n# files between Windows and either Mac or Linux.\nprint (t.split(\"\\n\"))", "['1st line', '2nd line', '3rd line']\n" ], [ "# Cross platform (ie better) solution\nprint(t.splitlines())", "['1st line', '2nd line', '3rd line']\n" ] ], [ [ "### Stripping off leading/trailing whitespace\nWhen processing text from a file and composing new strings, we frequently need to trim leading and trailing whitespaces:", "_____no_output_____" ] ], [ [ "s = \" text with leading and trailing spaces \\n\"\nprint(\"-->%s<--\"%s.strip())", "-->text with leading and trailing spaces<--\n" ], [ "# left strip\nprint(\"-->%s<--\"%s.lstrip())", "-->text with leading and trailing spaces \n<--\n" ], [ "# right strip\nprint(\"-->%s<--\"%s.rstrip())", "--> text with leading and trailing spaces<--\n" ] ], [ [ "### join() (the opposite of split())\nWe can join a list of substrings to form a new string. Similarly to *split()* we put strings together with a delimiter inbetween:", "_____no_output_____" ] ], [ [ "strings = [\"Newton\", \"Secant\", \"Bisection\"]\nprint(\", \".join(strings))", "Newton, Secant, Bisection\n" ] ], [ [ "You can prove to yourself that these are inverse operations:", "_____no_output_____" ] ], [ [ "t = delimiter.join(stringlist)\nstringlist = t.split(delimiter)", "_____no_output_____" ] ], [ [ "As an example, let's split off the first two words on a line:", "_____no_output_____" ] ], [ [ "line = \"This is a line of words separated by space\"\nwords = line.split()\nprint(\"words = \", words)\nline2 = \" \".join(words[2:])\nprint(\"line2 = \", line2)", "words = ['This', 'is', 'a', 'line', 'of', 'words', 'separated', 'by', 'space']\nline2 = a line of words separated by space\n" ] ], [ [ "## <span style=\"color:blue\">Exercise 6.7: Improve a program</span>\nThe file [data/densities.dat](https://raw.githubusercontent.com/ggorman/Introduction-to-programming-for-geoscientists/master/notebook/data/densities.dat) contains a table of densities of various substances measured in g/cm$^3$. The following program reads the data in this file and produces a dictionary whose keys are the names of substances, and the values are the corresponding densities.", "_____no_output_____" ] ], [ [ "def read_densities(filename):\n infile = open(filename, 'r')\n densities = {}\n for line in infile:\n words = line.split()\n density = float(words[-1])\n \n if len(words[:-1]) == 2:\n substance = words[0] + ' ' + words[1]\n else:\n substance = words[0]\n \n densities[substance] = density\n \n infile.close()\n return densities\n\ndensities = read_densities('data/densities.dat')\nprint(densities)", "{'air': 0.0012, 'gasoline': 0.67, 'ice': 0.9, 'pure water': 1.0, 'seawater': 1.025, 'human body': 1.03, 'limestone': 2.6, 'granite': 2.7, 'iron': 7.8, 'silver': 10.5, 'mercury': 13.6, 'gold': 18.9, 'platinium': 21.4, 'Earth mean': 5.52, 'Earth core': 13.0, 'Moon': 3.3, 'Sun mean': 1.4, 'Sun core': 160.0, 'proton': 280000000000000.0}\n" ] ], [ [ "One problem we face when implementing the program above is that the name of the substance can contain one or two words, and maybe more words in a more comprehensive table. The purpose of this exercise is to use string operations to shorten the code and make it more general. Implement the following two methods in separate functions `read_densities_join` and `read_densities_substrings`, and control that they give the same result.\n\n1. Let *substance* consist of all the words but the last, using the join method in string objects to combine the words.\n2. Observe that all the densities start in the same column file and use substrings to divide line into two parts. (Hint: Remember to strip the first part such that, e.g., the density of ice is obtained as *densities['ice']* and not *densities['ice ']*.)", "_____no_output_____" ] ], [ [ "def read_densities_join(filename):\n infile = open(filename, 'r')\n densities = {}\n for line in infile:\n words = line.split()\n density = float(words.pop()) # pop is a list operation that removes the last element from a list and returns it\n substance = \"_\".join(words) # join the remaining words with _\n densities[substance] = density\n infile.close()\n return densities\n\ndef read_densities_substrings(filename):\n infile = open(filename, 'r')\n densities = {}\n for line in infile:\n density = float(line[12:]) # column 13 onwards\n substance = line[:12] # upto coumn 12\n substance = substance.strip() # remove trailing spaces\n substance = substance.replace(\" \", \"_\") # replace spaces with _\n densities[substance] = density\n infile.close()\n return densities\n\ndensities_join = read_densities_join('data/densities.dat')\ndensities_substrings = read_densities_substrings('data/densities.dat')\nprint(densities_join)\nprint(densities_substrings)", "{'air': 0.0012, 'gasoline': 0.67, 'ice': 0.9, 'pure_water': 1.0, 'seawater': 1.025, 'human_body': 1.03, 'limestone': 2.6, 'granite': 2.7, 'iron': 7.8, 'silver': 10.5, 'mercury': 13.6, 'gold': 18.9, 'platinium': 21.4, 'Earth_mean': 5.52, 'Earth_core': 13.0, 'Moon': 3.3, 'Sun_mean': 1.4, 'Sun_core': 160.0, 'proton': 280000000000000.0}\n{'air': 0.0012, 'gasoline': 0.67, 'ice': 0.9, 'pure_water': 1.0, 'seawater': 1.025, 'human_body': 1.03, 'limestone': 2.6, 'granite': 2.7, 'iron': 7.8, 'silver': 10.5, 'mercury': 13.6, 'gold': 18.9, 'platinium': 21.4, 'Earth_mean': 5.52, 'Earth_core': 13.0, 'Moon': 3.3, 'Sun_mean': 1.4, 'Sun_core': 160.0, 'proton': 280000000000000.0}\n" ], [ "ok.grade('lect6-q7')", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nRunning tests\n\n---------------------------------------------------------------------\nTest summary\n Passed: 2\n Failed: 0\n[ooooooooook] 100.0% passed\n\n" ] ], [ [ "## File writing\nWriting a file in Python is simple. You just collect the text you want to write in one or more strings and, for each string, use a statement along the lines of", "_____no_output_____" ] ], [ [ "outfile.write(string)", "_____no_output_____" ] ], [ [ "The write function does not add a newline character so you may have to do that explicitly:", "_____no_output_____" ] ], [ [ "outfile.write(string + ’\\n’)", "_____no_output_____" ] ], [ [ "That’s it! Compose the strings and write! Let's do an example. Write a nested list (table) to a file:", "_____no_output_____" ] ], [ [ "# Let's define some table of data\ndata = [[ 0.75, 0.29619813, -0.29619813, -0.75 ],\n [ 0.29619813, 0.11697778, -0.11697778, -0.29619813],\n [-0.29619813, -0.11697778, 0.11697778, 0.29619813],\n [-0.75, -0.29619813, 0.29619813, 0.75 ]]\n\n# Open the file for writing. Notice the \"w\" indicates we are writing!\noutfile = open(\"tmp_table.dat\", \"w\")\nfor row in data:\n for column in row:\n outfile.write(\"%14.8f\" % column)\n outfile.write(\"\\n\") # ensure newline\noutfile.close()", "_____no_output_____" ] ], [ [ "And that's it - run the above cell and take a look at the file that was generated in your Azure library clone.", "_____no_output_____" ], [ "## <span style=\"color:blue\">Exercise 6.8: Write function data to a file</span>\nWe want to dump $x$ and $f(x)$ values to a file named function_data.dat, where the $x$ values appear in the first column and the $f(x)$ values appear in the second. Choose $n$ equally spaced $x$ values in the interval [-4, 4]. Here, the function $f(x)$ is given by:\n\n$f(x) = \\frac{1}{\\sqrt{2\\pi}}\\exp(-0.5x^2)$", "_____no_output_____" ] ], [ [ "from math import pi\n\n# define our function\ndef f(x):\n return (1.0/sqrt(2.0*pi))*exp(-.5*x**2.0)\n\n# let's make our x\nxarray = linspace(-4.0, 4.0, 100)\nfxs = f(xarray)\nfxs[-1] += 1\n\n# let's zip them up for a simple for loop when writing out\ndata = zip(xarray, fxs) # this combines each element into a tuple e.g. [(xarray1, fxs1), (xarray2, fxs2) ...]\n\n# write out\noutfile = open(\"ex8_out.dat\", \"w\") # w is for writing!\nfor x,y in data:\n outfile.write(\"X = %.2f Y = %.2f\" % (x, y))\n outfile.write(\"\\n\") # ensure newline\noutfile.close()", "_____no_output_____" ], [ "ok.grade('lect6-q8')", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nRunning tests\n\n---------------------------------------------------------------------\nquestion 6.8 > Suite 2 > Case 3\n\nfile_array = a = np.loadtxt(\"ex8_out.dat\", usecols=(2, 5))\n>>> np.array_equal(a[-1], [4., 0.])\nFalse\n\n# Error: expected\n# True\n# but got\n# False\n\nRun only this test case with \"python3 ok -q lect6-q8 --suite 2 --case 3\"\n---------------------------------------------------------------------\nTest summary\n Passed: 3\n Failed: 1\n[oooooook...] 75.0% passed\n\n" ], [ " ok.score()", "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\nScoring tests\n\n---------------------------------------------------------------------\nquestion 0\n Passed: 2\n Failed: 0\n[ooooooooook] 100.0% passed\n\n---------------------------------------------------------------------\nquestion 6.1\n Passed: 3\n Failed: 0\n[ooooooooook] 100.0% passed\n\n" ] ] ]

[ "markdown", "code", "markdown", "raw", "markdown", "raw", "markdown", "code", "markdown", "raw", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "raw", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "raw", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "raw", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "raw", "markdown", "raw", "markdown", "code", "markdown", "code" ]

[ [ "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "raw" ], [ "markdown" ], [ "raw" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "raw" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "raw" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "raw" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "raw" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "raw" ], [ "markdown" ], [ "raw" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "###DemLin02:\n#Ill-conditioning of Vandermonde matrix\n* todo: Review this demo, result not the same as in Miranda's\n\n", "_____no_output_____" ] ], [ [ "import numpy as np\nfrom numpy.linalg import norm, cond, solve\nimport time\nimport matplotlib.pyplot as plt\n%matplotlib notebook\nnp.set_printoptions(precision=4)", "_____no_output_____" ] ], [ [ "Compute approximation error and matrix condition number", "_____no_output_____" ] ], [ [ "n = np.arange(6, 51)\nnn = n.size\n\nerrv = np.zeros(nn)\nconv = np.zeros(nn)\n\nfor i in range(nn):\n v = np.vander(1 + np.arange(n[i]))\n errv[i] = np.log10(norm(np.identity(n[i]) - solve(v, v)))\n conv[i] = np.log10(cond(v))\n\nprint('errv =\\n', errv)", "errv =\n [-11.0688 -14.6779 -12.5801 -6.8825 -5.5384 -5.9532 -7.6494 -5.9833\n -5.6239 -6.3194 -5.651 -5.8029 -4.5616 -5.6639 -4.912 -5.0873\n -4.958 -5.8492 -5.0541 -5.6499 -5.7562 -5.6496 -5.8851 -5.7686\n -5.475 -5.3383 -5.4446 -5.0718 -5.4484 -5.3056 -5.3707 -5.7315\n -5.7709 -6.0165 -5.7509 -5.0538 -5.838 -6.063 -6.0756 -2.9206\n -5.0652 -5.759 -5.8286 -6.3859 -6.0894]\n" ] ], [ [ "Smooth using quadratic function", "_____no_output_____" ] ], [ [ "X = np.vstack([np.ones(nn), n]).T\nb = np.linalg.lstsq(X, errv)[0]\nerrv = np.dot(X, b)\nprint('b = ', b)\n\n\nb = np.linalg.lstsq(X, conv)[0]\nconv = np.dot(X, b)\nprint('b = ', b)", "b = [-8.003 0.0681]\nb = [1.0590e+01 9.1579e-03]\n" ] ], [ [ "Plot matrix condition numbers", "_____no_output_____" ] ], [ [ "plt.figure(figsize=[12, 5])\nplt.subplot(1, 2, 1)\nplt.plot(n, conv)\nplt.xlabel('n')\nplt.ylabel('Log_{10} Condition Number')\nplt.title('Vandermonde Matrix Condition Numbers')", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.", "_____no_output_____" ], [ "!pip install tf-nightly-2.0-preview\n", "_____no_output_____" ], [ "import tensorflow as tf\nimport numpy as np\nimport matplotlib.pyplot as plt\nprint(tf.__version__)", "2.0.0-dev20190628\n" ], [ "def plot_series(time, series, format=\"-\", start=0, end=None):\n plt.plot(time[start:end], series[start:end], format)\n plt.xlabel(\"Time\")\n plt.ylabel(\"Value\")\n plt.grid(True)\n\ndef trend(time, slope=0):\n return slope * time\n\ndef seasonal_pattern(season_time):\n \"\"\"Just an arbitrary pattern, you can change it if you wish\"\"\"\n return np.where(season_time < 0.4,\n np.cos(season_time * 2 * np.pi),\n 1 / np.exp(3 * season_time))\n\ndef seasonality(time, period, amplitude=1, phase=0):\n \"\"\"Repeats the same pattern at each period\"\"\"\n season_time = ((time + phase) % period) / period\n return amplitude * seasonal_pattern(season_time)\n\ndef noise(time, noise_level=1, seed=None):\n rnd = np.random.RandomState(seed)\n return rnd.randn(len(time)) * noise_level\n\ntime = np.arange(4 * 365 + 1, dtype=\"float32\")\nbaseline = 10\nseries = trend(time, 0.1) \nbaseline = 10\namplitude = 40\nslope = 0.05\nnoise_level = 5\n\n# Create the series\nseries = baseline + trend(time, slope) + seasonality(time, period=365, amplitude=amplitude)\n# Update with noise\nseries += noise(time, noise_level, seed=42)\n\nsplit_time = 1000\ntime_train = time[:split_time]\nx_train = series[:split_time]\ntime_valid = time[split_time:]\nx_valid = series[split_time:]\n\nwindow_size = 20\nbatch_size = 32\nshuffle_buffer_size = 1000", "_____no_output_____" ], [ "def windowed_dataset(series, window_size, batch_size, shuffle_buffer):\n dataset = tf.data.Dataset.from_tensor_slices(series)\n dataset = dataset.window(window_size + 1, shift=1, drop_remainder=True)\n dataset = dataset.flat_map(lambda window: window.batch(window_size + 1))\n dataset = dataset.shuffle(shuffle_buffer).map(lambda window: (window[:-1], window[-1]))\n dataset = dataset.batch(batch_size).prefetch(1)\n return dataset", "_____no_output_____" ], [ "tf.keras.backend.clear_session()\ntf.random.set_seed(51)\nnp.random.seed(51)\n\ntf.keras.backend.clear_session()\ndataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)\n\nmodel = tf.keras.models.Sequential([\n tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1),\n input_shape=[None]),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),\n tf.keras.layers.Dense(1),\n tf.keras.layers.Lambda(lambda x: x * 100.0)\n])\n\nlr_schedule = tf.keras.callbacks.LearningRateScheduler(\n lambda epoch: 1e-8 * 10**(epoch / 20))\noptimizer = tf.keras.optimizers.SGD(lr=1e-8, momentum=0.9)\nmodel.compile(loss=tf.keras.losses.Huber(),\n optimizer=optimizer,\n metrics=[\"mae\"])\nhistory = model.fit(dataset, epochs=100, callbacks=[lr_schedule])", "Epoch 1/100\n" ], [ "plt.semilogx(history.history[\"lr\"], history.history[\"loss\"])\nplt.axis([1e-8, 1e-4, 0, 30])", "_____no_output_____" ], [ "tf.keras.backend.clear_session()\ntf.random.set_seed(51)\nnp.random.seed(51)\n\ntf.keras.backend.clear_session()\ndataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)\n\nmodel = tf.keras.models.Sequential([\n tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1),\n input_shape=[None]),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),\n tf.keras.layers.Dense(1),\n tf.keras.layers.Lambda(lambda x: x * 100.0)\n])\n\n\nmodel.compile(loss=\"mse\", optimizer=tf.keras.optimizers.SGD(lr=1e-5, momentum=0.9),metrics=[\"mae\"])\nhistory = model.fit(dataset,epochs=500,verbose=0)", "_____no_output_____" ], [ "forecast = []\nresults = []\nfor time in range(len(series) - window_size):\n forecast.append(model.predict(series[time:time + window_size][np.newaxis]))\n\nforecast = forecast[split_time-window_size:]\nresults = np.array(forecast)[:, 0, 0]\n\n\nplt.figure(figsize=(10, 6))\n\nplot_series(time_valid, x_valid)\nplot_series(time_valid, results)", "_____no_output_____" ], [ "tf.keras.metrics.mean_absolute_error(x_valid, results).numpy()", "_____no_output_____" ], [ "import matplotlib.image as mpimg\nimport matplotlib.pyplot as plt\n\n#-----------------------------------------------------------\n# Retrieve a list of list results on training and test data\n# sets for each training epoch\n#-----------------------------------------------------------\nmae=history.history['mae']\nloss=history.history['loss']\n\nepochs=range(len(loss)) # Get number of epochs\n\n#------------------------------------------------\n# Plot MAE and Loss\n#------------------------------------------------\nplt.plot(epochs, mae, 'r')\nplt.plot(epochs, loss, 'b')\nplt.title('MAE and Loss')\nplt.xlabel(\"Epochs\")\nplt.ylabel(\"Accuracy\")\nplt.legend([\"MAE\", \"Loss\"])\n\nplt.figure()\n\nepochs_zoom = epochs[200:]\nmae_zoom = mae[200:]\nloss_zoom = loss[200:]\n\n#------------------------------------------------\n# Plot Zoomed MAE and Loss\n#------------------------------------------------\nplt.plot(epochs_zoom, mae_zoom, 'r')\nplt.plot(epochs_zoom, loss_zoom, 'b')\nplt.title('MAE and Loss')\nplt.xlabel(\"Epochs\")\nplt.ylabel(\"Accuracy\")\nplt.legend([\"MAE\", \"Loss\"])\n\nplt.figure()", "_____no_output_____" ], [ "tf.keras.backend.clear_session()\ndataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)\n\nmodel = tf.keras.models.Sequential([\n tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1),\n input_shape=[None]),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),\n tf.keras.layers.Dense(1),\n tf.keras.layers.Lambda(lambda x: x * 100.0)\n])\n\n\nmodel.compile(loss=\"mse\", optimizer=tf.keras.optimizers.SGD(lr=1e-6, momentum=0.9))\nmodel.fit(dataset,epochs=100, verbose=0)", "_____no_output_____" ], [ "tf.keras.backend.clear_session()\ndataset = windowed_dataset(x_train, window_size, batch_size, shuffle_buffer_size)\n\nmodel = tf.keras.models.Sequential([\n tf.keras.layers.Lambda(lambda x: tf.expand_dims(x, axis=-1),\n input_shape=[None]),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32, return_sequences=True)),\n tf.keras.layers.Bidirectional(tf.keras.layers.LSTM(32)),\n tf.keras.layers.Dense(1),\n tf.keras.layers.Lambda(lambda x: x * 100.0)\n])\n\n\nmodel.compile(loss=\"mse\", optimizer=tf.keras.optimizers.SGD(lr=1e-6, momentum=0.9))\nmodel.fit(dataset,epochs=100)", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "ADSL" ]

[ "ADSL" ]

[ "ADSL" ]

[ [ [ "# Confusion Matrix\n\nA confusion matrix shows the predicted values vs. the actual values by counting the true positives, true negatives, false positives, and false negatives.", "_____no_output_____" ] ], [ [ "%matplotlib inline\nimport matplotlib.pyplot as plt\nimport pandas as pd", "_____no_output_____" ] ], [ [ "Generate some data", "_____no_output_____" ] ], [ [ "from sklearn.datasets import make_blobs\n\nX, y = make_blobs(n_samples=1000, centers=2, cluster_std=3, random_state=42)\n\nprint(f\"Labels: {y[:10]}\")\nprint(f\"Data: {X[:10]}\")", "Labels: [0 1 1 1 1 1 1 0 1 0]\nData: [[-2.12128686e-03 5.62516556e+00]\n [ 9.67298128e+00 3.12404959e-01]\n [ 1.35105358e+00 -2.34698296e+00]\n [ 6.20838530e+00 2.52069672e-01]\n [ 4.09843910e+00 1.15524924e+01]\n [ 7.56547173e+00 3.47645219e+00]\n [ 6.39996024e+00 5.48458714e-01]\n [-1.91963411e+00 1.11412974e+01]\n [ 1.72490863e+00 -2.16568481e+00]\n [-2.60857854e+00 1.43979597e+01]]\n" ], [ "# Visualizing both classes\nplt.scatter(X[:, 0], X[:, 1], c=y)", "_____no_output_____" ] ], [ [ "Split our data into training and testing data", "_____no_output_____" ] ], [ [ "from sklearn.model_selection import train_test_split\n\nX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=1)", "_____no_output_____" ] ], [ [ "Create a logistic regression model", "_____no_output_____" ] ], [ [ "from sklearn.linear_model import LogisticRegression\nclassifier = LogisticRegression()\nclassifier", "_____no_output_____" ] ], [ [ "Fit (train) our model by using the training data", "_____no_output_____" ] ], [ [ "classifier.fit(X_train, y_train)", "_____no_output_____" ] ], [ [ "Validate the model by using the test data", "_____no_output_____" ] ], [ [ "print(f\"Training Data Score: {classifier.score(X_train, y_train)}\")\nprint(f\"Testing Data Score: {classifier.score(X_test, y_test)}\")", "Training Data Score: 0.9533333333333334\nTesting Data Score: 0.956\n" ] ], [ [ "Create a confusion matrix", "_____no_output_____" ] ], [ [ "from sklearn.metrics import confusion_matrix\n\ny_true = y_test\ny_pred = classifier.predict(X_test)\nconfusion_matrix(y_true, y_pred)", "_____no_output_____" ] ], [ [ "The accuracy of the model on the test data is TP + TN / (TP + FP + TN + FN)", "_____no_output_____" ] ], [ [ "tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\naccuracy = (tp + tn) / (tp + fp + tn + fn) # (111 + 128) / (111 + 5 + 128 + 6)\nprint(f\"Accuracy: {accuracy}\")", "Accuracy: 0.956\n" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "ADSL" ]

[ "ADSL" ]

[ "ADSL" ]

[ [ [ "%matplotlib inline\nfrom matplotlib import style\nstyle.use('fivethirtyeight')\nimport matplotlib.pyplot as plt", "_____no_output_____" ], [ "import numpy as np\nimport pandas as pd", "_____no_output_____" ], [ "import datetime as dt", "_____no_output_____" ] ], [ [ "# Reflect Tables into SQLAlchemy ORM", "_____no_output_____" ] ], [ [ "# Python SQL toolkit and Object Relational Mapper\nimport sqlalchemy\nfrom sqlalchemy.ext.automap import automap_base\nfrom sqlalchemy.orm import Session\nfrom sqlalchemy import create_engine, func, inspect\nfrom sqlalchemy import desc", "_____no_output_____" ], [ "engine = create_engine(\"sqlite:///Resources/hawaii.sqlite\")\nconn = engine.connect()", "_____no_output_____" ], [ "inspector = inspect(engine)\ninspector.get_table_names()", "_____no_output_____" ], [ "# reflect an existing database into a new model\n# reflect the tables\nBase = automap_base()\nBase.prepare(engine, reflect=True)", "_____no_output_____" ], [ "# We can view all of the classes that automap found\nBase.classes.keys()", "_____no_output_____" ], [ "# Save references to each table\nME = Base.classes.measurement\nST = Base.classes.station", "_____no_output_____" ], [ "# Create our session (link) from Python to the DB\nsession = Session(engine)", "_____no_output_____" ] ], [ [ "# Exploratory Climate Analysis", "_____no_output_____" ] ], [ [ "first_row = session.query(ME).first()\nfirst_row.__dict__", "_____no_output_____" ], [ "first_row = session.query(ST).first()\nfirst_row.__dict__", "_____no_output_____" ], [ "columns = inspector.get_columns('measurement')\nfor column in columns:\n print(column[\"name\"], column[\"type\"])", "id INTEGER\nstation TEXT\ndate TEXT\nprcp FLOAT\ntobs FLOAT\n" ], [ "columns = inspector.get_columns('station')\nfor column in columns:\n print(column[\"name\"], column[\"type\"])", "id INTEGER\nstation TEXT\nname TEXT\nlatitude FLOAT\nlongitude FLOAT\nelevation FLOAT\n" ], [ "session.query(func.min(ME.date)).all()", "_____no_output_____" ], [ "session.query(func.max(ME.date)).all()", "_____no_output_____" ], [ "# Design a query to retrieve the last 12 months of precipitation data and plot the results\n# Calculate the date 1 year ago from the last data point in the database\n# Perform a query to retrieve the data and precipitation scores\n# Save the query results as a Pandas DataFrame and set the index to the date column\n# Sort the dataframe by date\n# Use Pandas Plotting with Matplotlib to plot the data\n\nprevious_year = dt.date(2017, 8, 23) - dt.timedelta(days=365)\n# print(previous_year)\n\nyear_query = session.query(ME.date, ME.prcp).\\\n filter(ME.date >= previous_year).\\\n order_by(ME.date).all()\n# year_query\n\nyear_data = pd.DataFrame(year_query)\nyear_data.set_index('date', inplace = True)\n\nyear_data.plot()\nplt.xticks(rotation = 'vertical')\n\n# plt.title('Last 12 Months of Precipitation')\nplt.xlabel('Date')\nplt.ylabel('Inches')\n\nplt.tight_layout()\nplt.show()", "_____no_output_____" ], [ "# Use Pandas to calcualte the summary statistics for the precipitation data\nyear_data.describe()", "_____no_output_____" ], [ "# Design a query to show how many stations are available in this dataset?\nsel = [func.count(ST.station)]\nstations = session.query(*sel).all()\nstations", "_____no_output_____" ], [ "# What are the most active stations? (i.e. what stations have the most rows)?\n# List the stations and the counts in descending order.\nsel = [ME.station, func.count(ME.station)]\nmost_active = session.query(*sel).\\\n group_by(ME.station).\\\n order_by(func.count(ME.station).desc()).all()\nmost_active", "_____no_output_____" ], [ "# Using the station id from the previous query, calculate the lowest temperature recorded, \n# highest temperature recorded, and average temperature of the most active station?\n#once i find the station with the most count from the measurment table we can query the min and max for that station\nsel = [func.min(ME.tobs), func.max(ME.tobs), func.avg(ME.tobs)]\nsession.query(*sel).\\\n filter(ME.station == 'USC00519281').all()", "_____no_output_____" ], [ "# Choose the station with the highest number of temperature observations.\n# Query the last 12 months of temperature observation data for this station and plot the results as a histogram\n#can use the same query as above but do a date filter\nsel = [ME.tobs]\ntobs_data = pd.DataFrame(session.query(*sel).\\\n filter(ME.date >= previous_year).\\\n filter(ME.station == 'USC00519281').all())\n# tobs_data\n\ntobs_data.plot.hist(bins=12)\nplt.xlabel('Temperature')\nplt.tight_layout()\nplt.show()", "_____no_output_____" ] ], [ [ "## Bonus Challenge Assignment", "_____no_output_____" ] ], [ [ "# This function called `calc_temps` will accept start date and end date in the format '%Y-%m-%d' \n# and return the minimum, average, and maximum temperatures for that range of dates\ndef calc_temps(start_date, end_date):\n \"\"\"TMIN, TAVG, and TMAX for a list of dates.\n \n Args:\n start_date (string): A date string in the format %Y-%m-%d\n end_date (string): A date string in the format %Y-%m-%d\n \n Returns:\n TMIN, TAVE, and TMAX\n \"\"\"\n \n return session.query(func.min(ME.tobs), func.avg(ME.tobs), func.max(ME.tobs)).\\\n filter(ME.date >= start_date).filter(ME.date <= end_date).all()\n\n# function usage example\nprint(calc_temps('2012-02-28', '2012-03-05'))", "[(62.0, 69.57142857142857, 74.0)]\n" ], [ "# Use your previous function `calc_temps` to calculate the tmin, tavg, and tmax \n# for your trip using the previous year's data for those same dates.\nstart_date = dt.date(2012, 2, 28) - dt.timedelta(days=365)\nend_date = dt.date(2012, 3, 5) - dt.timedelta(days=365)\n\ntrip_temps = calc_temps(start_date, end_date)\ntrip_temps", "_____no_output_____" ], [ "# Plot the results from your previous query as a bar chart. \n# Use \"Trip Avg Temp\" as your Title\n# Use the average temperature for the y value\n# Use the peak-to-peak (tmax-tmin) value as the y error bar (yerr)\nfig, ax = plt.subplots(figsize=plt.figaspect(2.))\navg_temp = trip_temps[0][1]\nxpos = 1\nbar = ax.bar(xpos, avg_temp, yerr=error, alpha=0.5, color='red', align='center')\nax.set(xticks=range(xpos), title=\"Trip Avg Temp\", ylabel=\"Temperature (F)\")\nax.margins(.5, .5)\nfig.tight_layout()\nfig.show()", "C:\\Users\\salol\\anaconda3\\lib\\site-packages\\ipykernel_launcher.py:12: UserWarning: Matplotlib is currently using module://ipykernel.pylab.backend_inline, which is a non-GUI backend, so cannot show the figure.\n if sys.path[0] == '':\n" ], [ "# Calculate the total amount of rainfall per weather station for your trip dates using the previous year's matching dates.\n# Sort this in descending order by precipitation amount and list the station, name, latitude, longitude, and elevation\n\n", "_____no_output_____" ], [ "# Create a query that will calculate the daily normals \n# (i.e. the averages for tmin, tmax, and tavg for all historic data matching a specific month and day)\n\ndef daily_normals(date):\n \"\"\"Daily Normals.\n \n Args:\n date (str): A date string in the format '%m-%d'\n \n Returns:\n A list of tuples containing the daily normals, tmin, tavg, and tmax\n \n \"\"\"\n \n sel = [func.min(Measurement.tobs), func.avg(Measurement.tobs), func.max(Measurement.tobs)]\n return session.query(*sel).filter(func.strftime(\"%m-%d\", Measurement.date) == date).all()\n \ndaily_normals(\"01-01\")", "_____no_output_____" ], [ "# calculate the daily normals for your trip\n# push each tuple of calculations into a list called `normals`\n\n# Set the start and end date of the trip\n\n# Use the start and end date to create a range of dates\n\n# Stip off the year and save a list of %m-%d strings\n\n# Loop through the list of %m-%d strings and calculate the normals for each date\n", "_____no_output_____" ], [ "# Load the previous query results into a Pandas DataFrame and add the `trip_dates` range as the `date` index\n", "_____no_output_____" ], [ "# Plot the daily normals as an area plot with `stacked=False`\n", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Remote Sensing Hands-On Lesson, using TGO\n\n \n EPSC Conference, Berlin, September 18, 2018\n \n \n## Overview\n\n \n In this lesson you will develop a series of simple programs that\n demonstrate the usage of SpiceyPy to compute a variety of different\n geometric quantities applicable to experiments carried out by a remote\n sensing instrument flown on an interplanetary spacecraft. This\n particular lesson focuses on a spectrometer flying on the ExoMars2016 TGO\n spacecraft, but many of the concepts are easily extended and generalized\n to other scenarios.", "_____no_output_____" ], [ "## Importing SpiceyPy and Loading the Kernels\n", "_____no_output_____" ], [ "## Time Conversion \n\n\nWrite a program that prompts the user for an input UTC time string,\nconverts it to the following time systems and output formats:\n \n* Ephemeris Time (ET) in seconds past J2000\n* Calendar Ephemeris Time\n* Spacecraft Clock Time\n \nand displays the results. Use the program to convert \"2018 JUN 11\n19:32:00\" UTC into these alternate systems.", "_____no_output_____" ], [ "## Obtaining Target States and Positions\n \nWrite a program that prompts the user for an input UTC time string,\ncomputes the following quantities at that epoch:\n \n* The apparent state of Mars as seen from ExoMars2016 TGO in the J2000 frame, in kilometers and kilometers/second. This vector itself is not of any particular interest, but it is a useful intermediate quantity in some geometry calculations.\n \n* The apparent position of the Earth as seen from ExoMars2016 TGO in the J2000 frame, in kilometers.\n \n* The one-way light time between ExoMars2016 TGO and the apparent position of Earth, in seconds.\n \n* The apparent position of the Sun as seen from Mars in the J2000 frame (J2000), in kilometers.\n \n* The actual (geometric) distance between the Sun and Mars, in astronomical units.\n \nand displays the results. Use the program to compute these quantities at\n\"2018 JUN 11 19:32:00\" UTC.", "_____no_output_____" ], [ "## Spacecraft Orientation and Reference Frames\n\n \nWrite a program that prompts the user for an input time string, and\ncomputes and displays the following at the epoch of interest:\n \n* The apparent state of Mars as seen from ExoMars2016 TGO in the IAU_MARS body-fixed frame. This vector itself is not of any particular interest, but it is a useful intermediate quantity in some geometry calculations.\n \n* The angular separation between the apparent position of Mars as seen from ExoMars2016 TGO and the nominal instrument view direction.\n \n* The nominal instrument view direction is not provided by any kernel variable, but it is indicated in the ExoMars2016 TGO frame kernel.\n \nUse the program to compute these quantities at the epoch 2018 JUN 11\n 19:32:00 UTC.", "_____no_output_____" ], [ "## Computing Sub-s/c and Sub-solar Points on an Ellipsoid and a DSK \n\n \nWrite a program that prompts the user for an input UTC time string and computes the following quantities at that epoch:\n \n* The apparent sub-observer point of ExoMars2016 TGO on Mars, in the body fixed frame IAU_MARS, in kilometers.\n \n* The apparent sub-solar point on Mars, as seen from ExoMars2016 TGO in the body fixed frame IAU_MARS, in kilometers.\n \nThe program computes each point twice: once using an ellipsoidal shape model and the\n \n near point/ellipsoid\n \ndefinition, and once using a DSK shape model and the\n \n nadir/dsk/unprioritized\n \ndefinition.\n\nThe program displays the results. Use the program to compute these\n quantities at 2018 JUN 11 19:32:00 UTC.", "_____no_output_____" ], [ "## Intersecting Vectors with an Ellipsoid and a DSK (fovint)\n \n \n Write a program that prompts the user for an input UTC time string and,\n for that time, computes the intersection of the ExoMars-16 TGO NOMAD LNO\n Nadir aperture boresight and field of view (FOV) boundary vectors with\n the surface of Mars. Compute each intercept twice: once with Mars' shape\n modeled as an ellipsoid, and once with Mars' shape modeled by DSK data.\n The program presents each point of intersection as\n \n* A Cartesian vector in the IAU_MARS frame\n* Planetocentric (latitudinal) coordinates in the IAU_MARS frame.\n \nFor each of the camera FOV boundary and boresight vectors, if an\n intersection is found, the program displays the results of the above\n computations, otherwise it indicates no intersection exists.\n \n At each point of intersection compute the following:\n \n* Phase angle\n* Solar incidence angle\n* Emission angle\n \nThese angles should be computed using both ellipsoidal and DSK shape\n models.\n \n Additionally compute the local solar time at the intercept of the\n spectrometer aperture boresight with the surface of Mars, using both\n ellipsoidal and DSK shape models.\n Use this program to compute values at 2018 JUN 11 19:32:00 UTC", "_____no_output_____" ] ] ]

[ "markdown" ]

[ [ "markdown", "markdown", "markdown", "markdown", "markdown", "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import numpy\nfrom context import vaeqst", "_____no_output_____" ], [ "import numpy\nfrom context import base", "_____no_output_____" ], [ "base.RandomCliffordGate(0,1)", "_____no_output_____" ] ], [ [ "# Random Clifford Circuit", "_____no_output_____" ], [ "## RandomCliffordGate", "_____no_output_____" ], [ "`RandomClifordGate(*qubits)` represents a random Clifford gate acting on a set of qubits. There is no further parameter to specify, as it is not any particular gate, but a placeholder for a generic random Clifford gate.\n\n**Parameters**\n- `*qubits`: indices of the set of qubits on which the gate acts on.\n\nExample:", "_____no_output_____" ] ], [ [ "gate = vaeqst.RandomCliffordGate(0,1)\ngate", "_____no_output_____" ] ], [ [ "`RandomCliffordGate.random_clifford_map()` evokes a random sampling of the Clifford unitary, return in the form of operator mapping table $M$ and the corresponding sign indicator $h$. Such that under the mapping, any Pauli operator $\\sigma_g$ specified by the binary representation $g$ (and localized within the gate support) gets mapped to\n$$\\sigma_g \\to \\prod_{i=1}^{2n} (-)^{h_i}\\sigma_{M_i}^{g_i}.$$\nThe binary representation is in the $g=(x_0,z_0,x_1,z_1,\\cdots)$ basis.", "_____no_output_____" ] ], [ [ "gate.random_clifford_map()", "_____no_output_____" ] ], [ [ "## RandomCliffordLayer", "_____no_output_____" ], [ "`RandomCliffordLayer(*gates)` represents a layer of random Clifford gates. \n\n**Parameters:**\n* `*gates`: quantum gates contained in the layer.\n\nThe gates in the same layer should not overlap with each other (all gates need to commute). To ensure this, we do not manually add gates to the layer, but using the higher level function `.gate()` provided by `RandomCliffordCircuit` (see discussion later).\n\nExample:", "_____no_output_____" ] ], [ [ "layer = vaeqst.RandomCliffordLayer(vaeqst.RandomCliffordGate(0,1),vaeqst.RandomCliffordGate(3,5))\nlayer", "_____no_output_____" ] ], [ [ "It hosts a list of gates:", "_____no_output_____" ] ], [ [ "layer.gates", "_____no_output_____" ] ], [ [ "Given the total number of qubits $N$, the layer can sample the Clifford unitary (as product of each gate) $U=\\prod_{a}U_a$, and represent it as a single operator mapping (because gates do not overlap, so they maps operators in different supports independently).", "_____no_output_____" ] ], [ [ "layer.random_clifford_map(6)", "_____no_output_____" ] ], [ [ "## RandomCliffordCircuit", "_____no_output_____" ], [ "`RandomCliffordCircuit()` represents a quantum circuit of random Clifford gates.", "_____no_output_____" ], [ "### Methods", "_____no_output_____" ], [ "#### Construct the Circuit\n\nExample: create a random Clifford circuit.", "_____no_output_____" ] ], [ [ "circ = vaeqst.RandomCliffordCircuit()", "_____no_output_____" ] ], [ [ "Use `.gate(*qubits)` to add random Clifford gates to the circuit.", "_____no_output_____" ] ], [ [ "circ.gate(0,1)\ncirc.gate(2,4)\ncirc.gate(1,4)\ncirc.gate(0,2)\ncirc.gate(3,5)\ncirc.gate(3,4)\ncirc", "_____no_output_____" ] ], [ [ "Gates will automatically arranged into layers. Each new gate added to the circuit will commute through the layers if it is not blocked by the existing gates.", "_____no_output_____" ], [ "If the number of qubits `.N` is not explicitly defined, it will be dynamically infered from the circuit width, as the largest qubit index of all gates + 1.", "_____no_output_____" ] ], [ [ "circ.N", "_____no_output_____" ] ], [ [ "#### Navigate in the Circuit", "_____no_output_____" ], [ "`.layers_forward()` and `.layers_backward()` provides two generators to iterate over layers in forward and backward order resepctively.", "_____no_output_____" ] ], [ [ "list(circ.layers_forward())", "_____no_output_____" ], [ "list(circ.layers_backward())", "_____no_output_____" ] ], [ [ "`.first_layer` and `.last_layer` points to the first and the last layers.", "_____no_output_____" ] ], [ [ "circ.first_layer", "_____no_output_____" ], [ "circ.last_layer", "_____no_output_____" ] ], [ [ "Use `.next_layer` and `.prev_layer` to move forward and backward.", "_____no_output_____" ] ], [ [ "circ.first_layer.next_layer, circ.last_layer.prev_layer", "_____no_output_____" ] ], [ [ "Locate a gate in the circuit.", "_____no_output_____" ] ], [ [ "circ.first_layer.next_layer.next_layer.gates[0]", "_____no_output_____" ] ], [ [ "#### Apply Circuit to State", "_____no_output_____" ], [ "`.forward(state)` and `.backward(state)` applies the circuit to transform the state forward / backward. \n* Each call will sample a new random realization of the random Clifford circuit.\n* The transformation will create a new state, the original state remains untouched.", "_____no_output_____" ] ], [ [ "rho = vaeqst.StabilizerState(6, r=0)\nrho", "_____no_output_____" ], [ "circ.forward(rho)", "_____no_output_____" ], [ "circ.backward(rho)", "_____no_output_____" ] ], [ [ "#### POVM", "_____no_output_____" ], [ "`.povm(nsample)` provides a generator to sample $n_\\text{sample}$ from the prior POVM based on the circuit by back evolution.", "_____no_output_____" ] ], [ [ "list(circ.povm(3))", "_____no_output_____" ] ], [ [ "## BrickWallRCC", "_____no_output_____" ], [ "`BrickWallRCC(N, depth)` is a subclass of `RandomCliffordCircuit`. It represents the circuit with 2-qubit gates arranged following a brick wall pattern.", "_____no_output_____" ] ], [ [ "circ = vaeqst.BrickWallRCC(16,2)\ncirc", "_____no_output_____" ] ], [ [ "Create an inital state as a computational basis state.", "_____no_output_____" ] ], [ [ "rho = vaeqst.StabilizerState(16, r=0)\nrho", "_____no_output_____" ] ], [ [ "Backward evolve the state to obtain the measurement operator.", "_____no_output_____" ] ], [ [ "circ.backward(rho)", "_____no_output_____" ] ], [ [ "## OnSiteRCC", "_____no_output_____" ], [ "`OnSiteRCC(N)` is a subclass of `RandomCliffordCircuit`. It represents the circuit of a single layer of on-site Clifford gates. It can be used to generate random Pauli states.", "_____no_output_____" ] ], [ [ "circ = vaeqst.OnSiteRCC(16)\ncirc", "_____no_output_____" ], [ "rho = vaeqst.StabilizerState(16, r=0)\ncirc.backward(rho)", "_____no_output_____" ] ], [ [ "## GlobalRCC", "_____no_output_____" ], [ "`GlobalRCC(N)` is a subclass of `RandomCliffordCircuit`. It represents the circuit consists of a global Clifford gate. It can be used to generate Clifford states.", "_____no_output_____" ] ], [ [ "circ = vaeqst.GlobalRCC(16)\ncirc", "_____no_output_____" ], [ "rho = vaeqst.StabilizerState(16, r=0)\ncirc.backward(rho)", "_____no_output_____" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code", "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "#!/usr/bin/env python3 Line 1\n# -*- coding: utf-8 -*- Line 2\n#----------------------------------------------------------------------------\n# Created By : Celotto Andrea, Palumbo Emanuele, Zafferani Alessandro Line 3\n# Created Date: 16/02/2022 12:30\n# version ='Beta 1.0'\n\nimport visa \nimport numpy as np\nimport serial\nimport time\nimport os\nfrom pathlib import Path\npath = os.getcwd()\npath = Path(path)\nprint(Path(str(path.parent) + '\\\\Classes\\\\') )\n\nimport sys\nsys.path.append(str(path.parent) + '\\\\Classes\\\\')\nfrom SIM928 import *", "C:\\Users\\oper\\Desktop\\labparamp\\QTLab2122\\TWPA\\Classes\n" ] ], [ [ "# Connessione", "_____no_output_____" ] ], [ [ "sim = SIM928('COM1','4')", "_____no_output_____" ], [ "sim.query('*IDN')", "_____no_output_____" ] ], [ [ "# Comandi", "_____no_output_____" ] ], [ [ "#accensione\nsim.set_output(1)", "_____no_output_____" ], [ "#set del voltaggio\nsim.set_voltage(4e-3)", "_____no_output_____" ], [ "sim.ask_voltage()", "Voltage = 0.004\r\n V\n" ] ], [ [ "# Disconnessione", "_____no_output_____" ] ], [ [ "sim.close_all()", "Stanford_Research_Systems,SIM928,s/n030465,ver2.2\n\nStanford_Research_Systems,SIM900,s/n152741,ver3.6\n\n" ] ] ]

[ "code", "markdown", "code", "markdown", "code", "markdown", "code" ]

[ [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Additional training functions", "_____no_output_____" ], [ "[`train`](/train.html#train) provides a number of extension methods that are added to [`Learner`](/basic_train.html#Learner) (see below for a list and details), along with three simple callbacks:\n\n- [`ShowGraph`](/train.html#ShowGraph)\n- [`GradientClipping`](/train.html#GradientClipping)\n- [`BnFreeze`](/train.html#BnFreeze)", "_____no_output_____" ] ], [ [ "from fastai.gen_doc.nbdoc import *\nfrom fastai.train import *\nfrom fastai.vision import *\n", "_____no_output_____" ] ], [ [ "## [`Learner`](/basic_train.html#Learner) extension methods", "_____no_output_____" ], [ "These methods are automatically added to all [`Learner`](/basic_train.html#Learner) objects created after importing this module. They provide convenient access to a number of callbacks, without requiring them to be manually created.", "_____no_output_____" ] ], [ [ "show_doc(fit_one_cycle)", "_____no_output_____" ], [ "show_doc(one_cycle_scheduler)", "_____no_output_____" ] ], [ [ "See [`OneCycleScheduler`](/callbacks.one_cycle.html#OneCycleScheduler) for details.", "_____no_output_____" ] ], [ [ "show_doc(lr_find)", "_____no_output_____" ] ], [ [ "See [`LRFinder`](/callbacks.lr_finder.html#LRFinder) for details.", "_____no_output_____" ] ], [ [ "show_doc(to_fp16)", "_____no_output_____" ] ], [ [ "See [`MixedPrecision`](/callbacks.fp16.html#MixedPrecision) for details.", "_____no_output_____" ] ], [ [ "show_doc(to_fp32)", "_____no_output_____" ], [ "show_doc(mixup)", "_____no_output_____" ] ], [ [ "See [`MixUpCallback`](/callbacks.mixup.html#MixUpCallback) for more details.", "_____no_output_____" ], [ "## Additional callbacks", "_____no_output_____" ], [ "We'll show examples below using our MNIST sample. As usual the `on_something` methods are directly called by the fastai library, no need to call them yourself.", "_____no_output_____" ] ], [ [ "path = untar_data(URLs.MNIST_SAMPLE)\ndata = ImageDataBunch.from_folder(path)", "_____no_output_____" ], [ "show_doc(ShowGraph, title_level=3)", "_____no_output_____" ] ], [ [ "```python\nlearn = create_cnn(data, models.resnet18, metrics=accuracy, callback_fns=ShowGraph)\nlearn.fit(3)\n```", "_____no_output_____" ], [ "", "_____no_output_____" ] ], [ [ "show_doc(ShowGraph.on_epoch_end)", "_____no_output_____" ], [ "show_doc(GradientClipping)", "_____no_output_____" ], [ "learn = create_cnn(data, models.resnet18, metrics=accuracy,\n callback_fns=partial(GradientClipping, clip=0.1))\nlearn.fit(1)", "_____no_output_____" ], [ "show_doc(GradientClipping.on_backward_end)", "_____no_output_____" ], [ "show_doc(BnFreeze)", "_____no_output_____" ] ], [ [ "For batchnorm layers where `requires_grad==False`, you generally don't want to update their moving average statistics, in order to avoid the model's statistics getting out of sync with its pre-trained weights. You can add this callback to automate this freezing of statistics (internally, it calls `eval` on these layers).", "_____no_output_____" ] ], [ [ "learn = create_cnn(data, models.resnet18, metrics=accuracy, callback_fns=BnFreeze)\nlearn.fit(1)", "_____no_output_____" ], [ "show_doc(BnFreeze.on_epoch_begin)", "_____no_output_____" ] ], [ [ "## Undocumented Methods - Methods moved below this line will intentionally be hidden", "_____no_output_____" ] ] ]

[ "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]