Datasets:

---

bigcode

/

jupyter-parsed

like 4

Follow

BigCode 1.35k

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "**Note: Please use the [pyEOF](https://pyeof.readthedocs.io/en/latest/installation.html) environment for this script**", "_____no_output_____" ], [ "This script is used to implement EOF, REOF and k-means clustering to get regions", "_____no_output_____" ] ], [ [ "from pyEOF import *\nimport numpy as np\nimport pandas as pd\nimport xarray as xr\nimport matplotlib.pyplot as plt\nimport gc\nimport warnings\nimport pickle\nfrom matplotlib.ticker import MaxNLocator\nfrom tqdm import tqdm\nfrom sklearn.cluster import KMeans\nimport cartopy.crs as ccrs\nimport cartopy.feature as cfeature\n\nwarnings.filterwarnings('ignore')\n\n# select region\ndef sel_extent(ds):\n return ds.sel(lat=slice(6,36),lon=slice(68,98))\n\n# path\nds_path = \"./data/daily_surface_pm25_RH50.nc\"\nmask_path = \"./data/land_mask.nc\"", "_____no_output_____" ] ], [ [ "## plot the time series of the mean PM2.5 \nWe decided to use April and August as the testing data", "_____no_output_____" ] ], [ [ "mask = xr.open_dataset(mask_path)\nds = sel_extent(xr.open_dataset(ds_path)).where(mask[\"mask\"])\n\nds[\"PM25\"].groupby('time.month').mean(dim=[\"lon\",\"lat\",\"time\"]).plot()\nplt.show()", "_____no_output_____" ] ], [ [ "## get the data and implement EOFs\nBased on the results, we will select 4 PCs (n=4) and implemented varimax rotated EOFs (REOFs)", "_____no_output_____" ] ], [ [ "n=28\n\n# remove months \"4\" (April) and \"8\" (August), to be consistant with training data\nds = ds.sel(time=ds.time.dt.month.isin([1,2,3,\n 5,6,7,\n 9,10,11,12]))\ndf = ds[\"PM25\"].to_dataframe().reset_index() # get df from ds\n\n# process the data for implementing pyEOF\ndf_data = get_time_space(df, time_dim = \"time\", lumped_space_dims = [\"lat\",\"lon\"])\n\n# implement PCA/EOF\npca = df_eof(df_data)\neofs = pca.eofs(s=2, n=n)\neofs_ds = eofs.stack([\"lat\",\"lon\"], dropna=False).to_xarray()\npcs = pca.pcs(s=2, n=n)\nevf = pca.evf(n=n)\n\n# show the results\ndf = pd.DataFrame({\"n\":np.arange(1,n+1),\n \"evf\":pca.evf(n)*100.0,\n \"accum\":pca.evf(n).cumsum()*100.0\n })\n\nplt.scatter(df[\"n\"],df[\"accum\"], s=8)\nplt.axhline(y=50,c=\"r\",ls=\"-.\")\nplt.xlabel(\"# of PCs\")\nplt.ylabel(\"acc. explained variance [%]\")\nplt.show()\n\ndisplay(df.transpose())", "_____no_output_____" ] ], [ [ "## implement REOFs", "_____no_output_____" ] ], [ [ "n=4\n\n# implement REOF\npca = df_eof(df_data,pca_type=\"varimax\",n_components=n)\neofs = pca.eofs(s=2, n=n)\neofs_ds = eofs.stack([\"lat\",\"lon\"], dropna=False).to_xarray()\npcs = pca.pcs(s=2, n=n)\nevf = pca.evf(n=n)\n\ndf = pd.DataFrame({\"n\":np.arange(1,n+1),\n \"evf\":pca.evf(n)*100.0,\n \"accum\":pca.evf(n).cumsum()*100.0\n })\n\n# show the reults\nfig = plt.figure(figsize=(6,2))\n\nax = fig.add_subplot(121)\nax.scatter(df[\"n\"],df[\"evf\"], s=8)\nax.set_ylim(0,20)\nax.set_ylabel(\"explained variance [%]\")\nax.set_xlabel(\"PC\")\n\nax = fig.add_subplot(122)\nax.scatter(df[\"n\"],df[\"accum\"], s=8)\nax.set_ylim(0,60)\nax.set_ylabel(\"acc. explained variance [%]\")\nax.set_xlabel(\"PC\")\nax.axhline(y=50,c=\"r\",ls=\"-.\")\n\nplt.tight_layout()\nplt.show()\n\nprint(\"explained variance and acc. explained variance\")\ndisplay(df.transpose())\n\nprint(\"EOFs loading\")\neofs.transpose().describe().loc[[\"max\",\"min\"]].transpose()\n\neofs_ds = eofs.stack([\"lat\",\"lon\"], dropna=False).to_xarray()\nfig = plt.figure(figsize=(10,2))\nfor i in range(1,n+1):\n ax = fig.add_subplot(1,4,i)\n eofs_ds[\"PM25\"].sel(EOF=i).plot(ax=ax,vmax=1.0,vmin=-1.0,cbar_kwargs={'label': \"\"},cmap=\"bwr\")\nplt.tight_layout()\nplt.show()", "_____no_output_____" ] ], [ [ "## weighted EOFs loading", "_____no_output_____" ] ], [ [ "eofs_w = pd.DataFrame(data = (eofs.values * evf.reshape(n,1)),\n index = eofs.index,\n columns = eofs.columns)\n\neofs_w_ds = eofs_w.stack([\"lat\",\"lon\"], dropna=False).to_xarray()\nfig = plt.figure(figsize=(10,2))\nfor i in range(1,n+1):\n ax = fig.add_subplot(1,4,i)\n eofs_w_ds[\"PM25\"].sel(EOF=i).plot(ax=ax,cmap=\"bwr\",\n vmax=1.0*evf[i-1],\n vmin=-1.0*evf[i-1],\n cbar_kwargs={'label': \"\"})\nplt.tight_layout()\nplt.show()", "_____no_output_____" ] ], [ [ "## implement k-Means", "_____no_output_____" ] ], [ [ "# get the index which is not \"nan\"\nplaceholder_idx = np.argwhere(~np.isnan((eofs_w.values)[0])).reshape(-1)\n# get the matrix without missing values: locations (row) * EOFs (columns)\nm = eofs_w.values[:,placeholder_idx].transpose()\n# clustering and calculate the Sum_of_squared_distances\nSum_of_squared_distances = []\n\nK = range(2,15)\nfor n_clusters in tqdm(K):\n kmeans = KMeans(n_clusters=n_clusters, random_state=66).fit(m)\n Sum_of_squared_distances.append(kmeans.inertia_)\n \nssd = Sum_of_squared_distances\nresidual_x = K[1:]\nresidual = [(x - y) for x,y in zip(ssd,ssd[1:])]\npd.DataFrame({\"n_clusters\":K, \"ssd\":Sum_of_squared_distances}).transpose()", "100%|██████████| 13/13 [00:01<00:00, 6.59it/s]\n" ], [ "fig = plt.figure(figsize=(8,4))\ncluster_list = [3,4,5,6,7,8]\nfor i in range(len(cluster_list)):\n n_cluster = cluster_list[i]\n ax = fig.add_subplot(2,3,i+1)\n clusters = KMeans(n_clusters=n_cluster, random_state=66).fit_predict(m)\n\n df_f = eofs.copy()\n df_f.loc[str(n+1),:] = np.nan\n df_f.iloc[n,placeholder_idx] = clusters\n\n df_fs = df_f.stack([\"lat\",\"lon\"], dropna=False).to_xarray()\n df_fs.sel(EOF=str(n+1))[\"PM25\"].plot(ax=ax, cbar_kwargs={\"label\":\"cluster\"})\n ax.set_title(f\"clusters={n_cluster}\")\nplt.tight_layout()\nplt.show()", "_____no_output_____" ] ], [ [ "## we select n_cluster = 6 to further the analysis", "_____no_output_____" ] ], [ [ "n_cluster = 6\n\nfig = plt.figure(figsize=(8,3))\n\nax = fig.add_subplot(121)\nax.plot(K, Sum_of_squared_distances, 'bx-')\nax.plot(n_cluster,Sum_of_squared_distances[n_cluster-2],\"rx\")\nax.set_xlabel('number of clusters')\nax.set_ylabel('sum of squared distances')\n# ax.set_title('Elbow method for optimal number of clusters')\n\nax = fig.add_subplot(122)\nax.plot(residual_x, residual, 'bx-')\nax.set_xlabel('number of clusters')\nax.set_ylabel('diff. in ssd')\nax.plot(n_cluster,residual[n_cluster-3],\"rx\")\n# ax.set_title('difference in sum of squared distances')\nax.xaxis.set_major_locator(MaxNLocator(integer=True))\n\nplt.tight_layout()\nplt.show()", "_____no_output_____" ] ], [ [ "## use n_cluster = 6 to implement the clusters", "_____no_output_____" ] ], [ [ "clusters = KMeans(n_clusters=n_cluster, random_state=66).fit_predict(m)\n\ndf_f = eofs.copy()\ndf_f.loc[str(n+1),:] = np.nan\ndf_f.iloc[n,placeholder_idx] = clusters\n\nds_f = df_f.stack([\"lat\",\"lon\"], dropna=False).to_xarray()", "_____no_output_____" ], [ "fig = plt.figure(figsize=(3,3))\nax = fig.add_subplot(111, projection=ccrs.PlateCarree())\nax.set_extent([68,98,6,36],crs=ccrs.PlateCarree())\nds_regions = ds_f.sel(EOF=str(n+1))[\"PM25\"].drop(\"EOF\")\nds_regions.plot(ax=ax,cbar_kwargs={\"label\":\"cluster\"})\n# ax.add_feature(cfeature.STATES.with_scale('10m'),\n# facecolor='none',\n# edgecolor='black')\n# ax.add_feature(cfeature.BORDERS,edgecolor='red')\nplt.show()", "_____no_output_____" ] ], [ [ "## save the clusters masks", "_____no_output_____" ] ], [ [ "fig = plt.figure(figsize=(2*n_cluster,2))\nfor i in range(n_cluster):\n ax = fig.add_subplot(1,n_cluster,i+1)\n ds_f[\"mask_\"+str(i)] = ds_regions.where(ds_regions==i).notnull().squeeze()\n ds_f[\"mask_\"+str(i)].plot(ax=ax,cbar_kwargs={\"label\":\"\"})\n ax.set_title(\"mask_\"+str(i))\nplt.tight_layout()\nplt.show()\n\nmask_ls = [\"mask_\"+str(i) for i in range(n_cluster)]\nds_f[mask_ls].to_netcdf(\"./data/cluster_mask_\"+str(n_cluster)+\".nc\",engine=\"scipy\")", "_____no_output_____" ] ], [ [ "## save the regional masks", "_____no_output_____" ] ], [ [ "cluster_mask = xr.open_dataset(\"./data/cluster_mask_\"+str(n_cluster)+\".nc\",engine=\"scipy\")\nfig = plt.figure(figsize=(2*n_cluster,2))\nfor i in range(n_cluster):\n ax = fig.add_subplot(1,n_cluster,i+1)\n ds.mean(dim=\"time\").where(cluster_mask[\"mask_\"+str(i)])[\"PM25\"].plot(ax=ax,cbar_kwargs={\"label\":\"\"})\n ax.set_title(\"mask_\"+str(i))\n ax.set_xlabel(\"\")\n ax.set_ylabel(\"\")\nplt.tight_layout()\nplt.show()", "_____no_output_____" ], [ "# process\ncluster_mask[\"mask_\"+str(0)] = cluster_mask.where((cluster_mask.lon>=90) & (cluster_mask.lat>=15),0)[\"mask_\"+str(0)]\ncluster_mask[\"mask_\"+str(3)] = cluster_mask.where((cluster_mask.lat>=12) & (cluster_mask.lat<=30),0)[\"mask_\"+str(3)]\ncluster_mask[\"mask_\"+str(4)] = cluster_mask.where((cluster_mask.lat<=20.5) & (cluster_mask.lat>=8),0)[\"mask_\"+str(4)]\n\n# rename\ncluster_mask = cluster_mask[[\"mask_0\",\"mask_1\",\"mask_3\",\"mask_4\"]]\\\n .rename({\"mask_0\":\"E\",\"mask_1\":\"W\",\"mask_3\":\"N\",\"mask_4\":\"S\"})\nloc_name = list(cluster_mask)\n\nfig = plt.figure(figsize=(n_cluster*2,2))\nfor i in range(len(loc_name)):\n ax = fig.add_subplot(1,n_cluster,i+1)\n ds.mean(dim=\"time\").where(cluster_mask[loc_name[i]])[\"PM25\"].plot(ax=ax,cbar_kwargs={\"label\":\"\"})\n ax.set_title(loc_name[i])\n ax.set_xlabel(\"\")\n ax.set_ylabel(\"\")\nplt.tight_layout()\nplt.show()", "_____no_output_____" ] ], [ [ "## save and load the regional mask", "_____no_output_____" ] ], [ [ "# save the regional mask\ncluster_mask.to_netcdf(\"./data/r_mask.nc\",engine=\"scipy\")\n\n# load the regional mask\ntest = xr.open_dataset(\"./data/r_mask.nc\",engine=\"scipy\")\nfig = plt.figure(figsize=(n_cluster*2,2))\nfor i in range(len(loc_name)):\n ax = fig.add_subplot(1,n_cluster,i+1)\n ds.mean(dim=\"time\").where(test[loc_name[i]])[\"PM25\"].plot(ax=ax,cbar_kwargs={\"label\":\"\"})\n ax.set_title(loc_name[i])\n ax.set_xlabel(\"\")\n ax.set_ylabel(\"\")\nplt.tight_layout()\nplt.show()", "_____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", "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" ] ]

[ "ISC", "Apache-2.0", "CC0-1.0" ]

[ "ISC", "Apache-2.0", "CC0-1.0" ]

[ "ISC", "Apache-2.0", "CC0-1.0" ]

[ [ [ "", "_____no_output_____" ], [ "# Link Prediction - Introduction\nIn this Notebook we are going to examine the process of using Amazon Neptune ML feature to perform link prediction in a property graph. \n\n<div style=\"background-color:#eeeeee; padding:10px; text-align:left; border-radius:10px; margin-top:10px; margin-bottom:10px; \"><b>Note</b>: This notebook take approximately 1 hour to complete</div>\n\n[Neptune ML](https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning.html#machine-learning-overview) is a feature of Amazon Neptune that enables users to automate the creation, management, and usage of Graph Neural Network (GNN) machine learning models within Amazon Neptune. Neptune ML is built using [Amazon SageMaker](https://aws.amazon.com/sagemaker/) and [Deep Graph Library](https://www.dgl.ai/) and provides a simple and easy to use mechanism to build/train/maintain these models and then use the predictive capabilities of these models within a Gremlin query to predict elements or property values in the graph. \n\nFor this notebook we are going to show how to perform a common machine learning task known as **link prediction**. Link prediction is a unsupervised machine learning task where a model built using nodes and edges in the graph to predict whether an edge exists between two particular nodes. Link prediction is not unique to GNN based models (look at DeepWalk or node2vec) but the GNN based models in Neptune ML provide additional context to the predictions by combining the connectivity and features of the local neighborhood of a node to create a more predictive model.\n\nLink prediction is commonly used to solve many common buisness problems such as:\n\n* Predicting group membership in a social or identity network\n* [Entity Resolution in an identity graph](https://github.com/awslabs/sagemaker-graph-entity-resolution/blob/master/source/sagemaker/dgl-entity-resolution.ipynb)\n* Knowledge graph completion\n* Product recommendation\n\nNeptune ML uses a four step process to automate the process of creating production ready GNN models:\n\n1. **Load Data** - Data is loaded into a Neptune cluster using any of the normal methods such as the Gremlin drivers or using the Neptune Bulk Loader.\n2. **Export Data** - A service call is made specifying the machine learning model type and model configuration parameters. The data and model configuration parameters are then exported from a Neptune cluster to an S3 bucket.\n3. **Model Training** - A set of service calls are made to pre-process the exported data, train the machine learning model, and then generate an Amazon SageMaker endpoint that exposes the model.\n4. **Run Queries** - The final step is to use this inference endpoint within our Gremlin queries to infer data using the machine learning model.\n\n", "_____no_output_____" ], [ "For this notebook we'll use the [MovieLens 100k dataset](https://grouplens.org/datasets/movielens/100k/) provided by [GroupLens Research](https://grouplens.org/datasets/movielens/). This dataset consists of movies, users, and ratings of those movies by users. \n\n\n\nFor this notebook we'll walk through how Neptune ML can predict product recommendations in a product knowledge graph. To demonstrate this we'll predict the movies a user would be most likely to rate as well as which users are most likely to rate a given movie. We'll walk through each step of loading and exporting the data, configuring and training the model, and finally we'll show how to use that model to infer the genre of movies using Gremlin traversals. ", "_____no_output_____" ], [ "## Checking that we are ready to run Neptune ML \nRun the code below to check that this cluster is configured to run Neptune ML.", "_____no_output_____" ] ], [ [ "import neptune_ml_utils as neptune_ml\nneptune_ml.check_ml_enabled()", "_____no_output_____" ] ], [ [ "If the check above did not say that this cluster is ready to run Neptune ML jobs then please check that the cluster meets all the pre-requisites defined [here](https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning.html#machine-learning-overview).\n\n# Load the data\nThe first step in building a Neptune ML model is to load data into the Neptune cluster. Loading data for Neptune ML follows the standard process of ingesting data into Amazon Neptune, for this example we'll be using the Bulk Loader. \n\nWe have written a script that automates the process of downloading the data from the MovieLens websites and formatting it to load into Neptune. All you need to provide is an S3 bucket URI that is located in the same region as the cluster.\n\n<div style=\"background-color:#eeeeee; padding:10px; text-align:left; border-radius:10px; margin-top:10px; margin-bottom:10px; \"><b>Note</b>: This is the only step that requires any specific input from the user, all remaining cells will automatically propogate the required values.</div>", "_____no_output_____" ] ], [ [ "s3_bucket_uri=\"s3://<INSERT S3 BUCKET OR PATH>\"\n# remove trailing slashes\ns3_bucket_uri = s3_bucket_uri[:-1] if s3_bucket_uri.endswith('/') else s3_bucket_uri", "_____no_output_____" ] ], [ [ "Now that you have provided an S3 bucket, run the cell below which will download and format the MovieLens data into a format compatible with Neptune's bulk loader.", "_____no_output_____" ] ], [ [ "response = neptune_ml.prepare_movielens_data(s3_bucket_uri)", "_____no_output_____" ] ], [ [ "This process only takes a few minutes and once it has completed you can load the data using the `%load` command in the cell below.", "_____no_output_____" ] ], [ [ "%load -s {response} -f csv -p OVERSUBSCRIBE --run", "_____no_output_____" ] ], [ [ "## Check to make sure the data is loaded\n\nOnce the cell has completed, the data has been loaded into the cluster. We verify the data loaded correctly by running the traversals below to see the count of nodes by label: \n\n<div style=\"background-color:#eeeeee; padding:10px; text-align:left; border-radius:10px; margin-top:10px; margin-bottom:10px; \"><b>Note</b>: The numbers below assume no other data is in the cluster</div>", "_____no_output_____" ] ], [ [ "%%gremlin\ng.V().groupCount().by(label).unfold()", "_____no_output_____" ] ], [ [ "If our nodes loaded correctly then the output is:\n\n* 19 genres\n* 1682 movies\n* 100000 rating\n* 943 users\n\nTo check that our edges loaded correctly we check the edge counts:", "_____no_output_____" ] ], [ [ "%%gremlin\ng.E().groupCount().by(label).unfold()", "_____no_output_____" ] ], [ [ "If our edges loaded correctly then the output is:\n\n* 100000 about\n* 2893 included_in\n* 100000 rated\n* 100000 wrote\n\n\n## Preparing for export\n\nWith our data validated let's remove a few `rated` vertices so that we can build a model that predicts these missing connections. In a normal scenario, the data you would like to predict is most likely missing from the data being loaded so removing these values prior to building our machine learning model simulates that situation.\n\nSpecifically, let's remove the `rated` edgesfor `user_1`, to provide us with a few candidate vertices to run our link prediction tasks. Let's start by taking a look at what `rated` edges currently exist.", "_____no_output_____" ] ], [ [ "%%gremlin\n\ng.V('user_1').outE('rated')", "_____no_output_____" ] ], [ [ "Now let's remove these edges to simulate them missing from our data.", "_____no_output_____" ] ], [ [ "%%gremlin\ng.V('user_1').outE('rated').drop()", "_____no_output_____" ] ], [ [ "Checking our data again we see that the edges have now been removed.", "_____no_output_____" ] ], [ [ "%%gremlin\ng.V('user_1').outE('rated')", "_____no_output_____" ] ], [ [ "# Export the data and model configuration\n\n**Note:** Before exporting data ensure that Neptune Export has been configured as described here: [Neptune Export Service](https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning-data-export-service.html#machine-learning-data-export-service-run-export)", "_____no_output_____" ], [ "With our product knowledge graph loaded we are ready to export the data and configuration which will be used to train the ML model. \n\nThe export process is triggered by calling to the [Neptune Export service endpoint](https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning-data-export-service.html). This call contains a configuration object which specifies the type of machine learning model to build, in this example node classification, as well as any feature configurations required. \n\n<div style=\"background-color:#eeeeee; padding:10px; text-align:left; border-radius:10px; margin-top:10px; margin-bottom:10px; \"><b>Note</b>: The configuration used in this notebook specifies only a minimal set of configuration options meaning that our model's predictions are not as accurate as they could be. The parameters included in this configuration are one of a couple of sets of options available to the end user to tune the model and optimize the accuracy of the resulting predictions.</div>\n\nThe configuration options provided to the export service are broken into two main sections, selecting the target and configuring features. \n\n## Selecting the target\n\nIn the first section, selecting the target, we specify what type of machine learning task will be run. To run a link prediction mdoel do not specify any `targets` in the `additionalParams` value. Unlike node classification or node regression, link prediction can be used to predict any edge type that exists in the graph between any two vertices. Becasue of this, there is no need to define a target set of values.\n\n\n## Configuring features\nThe second section of the configuration, configuring features, is where we specify details about the types of data stored in our graph and how the machine learning model should interpret that data. In machine learning, each property is known as a feature and these features are used by the model to make predictions. \n\nIn machine learning, each property is known as a feature and these features are used by the model to make predictions. When data is exported from Neptune all properties of all vertices are included. Each property is treated as a separate feature for the ML model. Neptune ML does its best to infer the correct type of feature for a property, in many cases, the accuracy of the model can be improved by specifying information about the property used for a feature. By default Neptune ML puts features into one of two categories:\n\n* If the feature represents a numerical property (float, double, int) then it is treated as a `numerical` feature type. In this feature type data is represented as a continuous set of numbers. In our example, the `age` of a `user` would best be represented as a numerical feature as the age of a user is best represented as a continuous set of values.\n* All other property types are represented as `category` features. In this feature type, each unique value of data is represented as a unique value in the set of classifications used by the model. In our MovieLens example the `occupation` of a `user` would represent a good example of a `category` feature as we want to group users that all have the same job.\n\nIf all of the properties fit into these two feature types then no configuration changes are needed at the time of export. However, in many scenarios these defaults are not always the best choice. In these cases, additional configuration options should be specified to better define how the property should be represented as a feature. \n\nOne common feature that needs additional configuration is numerical data, and specifically properties of numerical data that represent chunks or groups of items instead of a continuous stream.\n\nLet's say that instead of wanting `age` to be represented as a set of continuous values we want to represent it as a set of discrete buckets of values (e.g. 18-25, 26-24, 35-44, etc.). In this scenario we want to specify some additional attributes of that feature to bucket this attribute into certain known sets. We achieve this by specifying this feature as a `numerical_bucket`. This feature type takes a range of expected values, as well as a number of buckets, and groups data into buckets during the training process.\n\nAnother common feature that needs additional attributes are text features such as names, titles, or descriptions. While Neptune ML will treat these as categorical features by default the reality of these features is that they will likely be unique for each node. For example, since the `title` property of a `movie` node does not fit into a category grouping our model would be better served by representing this type of feature as a `text_word2vec` feature. A `text_word2vec` feature uses techniques from natural language processing to create a vector of data that represents a string of text. \n\nIn our export example below we have specified that the `title` property of our `movie` should be exported and trained as a `text_word2vec` feature and that our `age` field should range from 0-100 and that data should be bucketed into 10 distinct groups. \n\n<div style=\"background-color:#eeeeee; padding:10px; text-align:left; border-radius:10px; margin-top:10px; margin-bottom:10px; \"><b>Important</b>: The example below is an example of a minimal amount of the features of the model configuration parameters and will not create the most accurate model possible. Additional options are available for tuning this configuration to produce an optimal model are described here: <a href=\"https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning-data-export-parameters.html\">Neptune Export Process Parameters</a></div>\n\nRunning the cell below we set the export configuration and run the export process. Neptune export is capable of automatically creating a clone of the cluster by setting `cloneCluster=True` which takes about 20 minutes to complete and will incur additional costs while the cloned cluster is running. Exporting from the existing cluster takes about 5 minutes but requires that the `neptune_query_timeout` parameter in the [parameter group](https://docs.aws.amazon.com/neptune/latest/userguide/parameters.html) is set to a large enough value (>72000) to prevent timeout errors.", "_____no_output_____" ] ], [ [ "export_params={ \n\"command\": \"export-pg\", \n\"params\": { \"endpoint\": neptune_ml.get_host(),\n \"profile\": \"neptune_ml\",\n \"cloneCluster\": False\n }, \n\"outputS3Path\": f'{s3_bucket_uri}/neptune-export',\n\"additionalParams\": {\n \"neptune_ml\": {\n \"version\": \"v2.0\",\n \"features\": [\n {\n \"node\": \"movie\",\n \"property\": \"title\",\n \"type\": \"word2vec\"\n },\n {\n \"node\": \"user\",\n \"property\": \"age\",\n \"type\": \"bucket_numerical\",\n \"range\" : [1, 100],\n \"num_buckets\": 10\n }\n ]\n }\n },\n\"jobSize\": \"medium\"}", "_____no_output_____" ], [ "%%neptune_ml export start --export-url {neptune_ml.get_export_service_host()} --export-iam --wait --store-to export_results\n${export_params}", "_____no_output_____" ] ], [ [ "# ML data processing, model training, and endpoint creation\n\nOnce the export job is completed we are now ready to train our machine learning model and create the inference endpoint. Training our Neptune ML model requires three steps. \n \n<div style=\"background-color:#eeeeee; padding:10px; text-align:left; border-radius:10px; margin-top:10px; margin-bottom:10px; \"><b>Note</b>: The cells below only configure a minimal set of parameters required to run a model training.</div>\n\n## Data processing\nThe first step (data processing) processes the exported graph dataset using standard feature preprocessing techniques to prepare it for use by DGL. This step performs functions such as feature normalization for numeric data and encoding text features using word2vec. At the conclusion of this step the dataset is formatted for model training. \n\nThis step is implemented using a SageMaker Processing Job and data artifacts are stored in a pre-specified S3 location once the job is complete.\n\nAdditional options and configuration parameters for the data processing job can be found using the links below:\n\n* [Data Processing](https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning-on-graphs-processing.html)\n* [dataprocessing command](https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning-api-dataprocessing.html)\n\nRun the cells below to create the data processing configuration and to begin the processing job.", "_____no_output_____" ] ], [ [ "# The training_job_name can be set to a unique value below, otherwise one will be auto generated\ntraining_job_name=neptune_ml.get_training_job_name('link-prediction')\n\nprocessing_params = f\"\"\"\n--config-file-name training-data-configuration.json\n--job-id {training_job_name} \n--s3-input-uri {export_results['outputS3Uri']} \n--s3-processed-uri {str(s3_bucket_uri)}/preloading \"\"\"", "_____no_output_____" ], [ "%neptune_ml dataprocessing start --wait --store-to processing_results {processing_params}", "_____no_output_____" ] ], [ [ "## Model training\nThe second step (model training) trains the ML model that will be used for predictions. The model training is done in two stages. The first stage uses a SageMaker Processing job to generate a model training strategy. A model training strategy is a configuration set that specifies what type of model and model hyperparameter ranges will be used for the model training. Once the first stage is complete, the SageMaker Processing job launches a SageMaker Hyperparameter tuning job. The SageMaker Hyperparameter tuning job runs a pre-specified number of model training job trials on the processed data, and stores the model artifacts generated by the training in the output S3 location. Once all the training jobs are complete, the Hyperparameter tuning job also notes the training job that produced the best performing model.\n\nAdditional options and configuration parameters for the data processing job can be found using the links below:\n\n* [Model Training](https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning-on-graphs-model-training.html)\n* [modeltraining command](https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning-api-modeltraining.html)\n\n<div style=\"background-color:#eeeeee; padding:10px; text-align:left; border-radius:10px; margin-top:10px; margin-bottom:10px; \"><b>Information</b>: Link prediction is a more computationally complex model than classification or regression so training this model will take 2-3 hours</div>", "_____no_output_____" ] ], [ [ "training_params=f\"\"\"\n--job-id {training_job_name} \n--data-processing-id {training_job_name} \n--instance-type ml.p3.2xlarge\n--s3-output-uri {str(s3_bucket_uri)}/training\n--max-hpo-number 2\n--max-hpo-parallel 2 \"\"\"", "_____no_output_____" ], [ "%neptune_ml training start --wait --store-to training_results {training_params}", "_____no_output_____" ] ], [ [ "## Endpoint creation\nThe final step is to create the inference endpoint which is an Amazon SageMaker endpoint instance that is launched with the model artifacts produced by the best training job. This endpoint will be used by our graph queries to return the model predictions for the inputs in the request. The endpoint once created stays active until it is manually deleted. Each model is tied to a single endpoint.\n\nAdditional options and configuration parameters for the data processing job can be found using the links below:\n\n* [Inference Endpoint](https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning-on-graphs-inference-endpoint.html)\n* [Endpoint command](https://docs.aws.amazon.com/neptune/latest/userguide/machine-learning-api-endpoints.html)\n\n<div style=\"background-color:#eeeeee; padding:10px; text-align:left; border-radius:10px; margin-top:10px; margin-bottom:10px; \"><b>Information</b>: The endpoint creation process takes ~5-10 minutes</div>", "_____no_output_____" ] ], [ [ "endpoint_params=f\"\"\"\n--id {training_job_name}\n--model-training-job-id {training_job_name}\"\"\"", "_____no_output_____" ], [ "%neptune_ml endpoint create --wait --store-to endpoint_results {endpoint_params}", "_____no_output_____" ] ], [ [ "Once this has completed we get the endpoint name for our newly created inference endpoint. The cell below will set the endpoint name which will be used in the Gremlin queries below. ", "_____no_output_____" ] ], [ [ "endpoint=endpoint_results['endpoint']['name']", "_____no_output_____" ] ], [ [ "# Querying using Gremlin\n\nNow that we have our inference endpoint setup let's query our product knowledge graph to show how to predict how likely it is that a user will rate a movie. The need to predict the likelyhood of connections in a product knowledge graph is commonly used to provide recommendations for products that a customer might purchase.\n\nUnlike node classification and node regression, link prediction can infer any of the edge labels that existed in our graph when the model was created. In our model this means we could infer the probability that a `wrote`, `about`, `rated`, or `included_in` edge exists between any two vertices. However for this example we are going to focus on inferring the `rated` edges between the `user` and `movie` vertices. \n\n## Predicting what movies a user will rate\n\nBefore we predict what movies `user_1` is most likely to rate let's verify that our graph does not contain any `rated` edges for `user_1`.\n", "_____no_output_____" ] ], [ [ "%%gremlin\ng.V('user_1').out('rated').hasLabel('movie').valueMap()", "_____no_output_____" ] ], [ [ "As expected, their are not any `rated` edges for `user_1`. Maybe `user_1` is a new user in our system and we want to provide them some product recommendations. Let's modify the query to predict what movies `user_1` is most likely to rate. \n\nFirst, we add the `with()` step to specify the inference endpoint we want to use with our Gremlin query like this\n`g.with(\"Neptune#ml.endpoint\",\"<INSERT ENDPOINT NAME>\")`. \n\n<div style=\"background-color:#eeeeee; padding:10px; text-align:left; border-radius:10px; margin-top:10px; margin-bottom:10px; \"><b>Note</b>: The endpoint values are automatically passed into the queries below</div>\n\nSecond, when we ask for the link within our query we use the `out()` step to predict the target node or the `in()` step to predict the source node. For each of these steps we need to specify the type of model being used with a with() step (`with(\"Neptune#ml.prediction\")`).\n\nPutting these items together we get the query below, which returns the movies that` user_1` is likely to rate.", "_____no_output_____" ] ], [ [ "%%gremlin\ng.with(\"Neptune#ml.endpoint\",\"${endpoint}\").\n V('user_1').out('rated').with(\"Neptune#ml.prediction\").hasLabel('movie').valueMap('title')", "_____no_output_____" ] ], [ [ "Great, we can now see that we are predicted edges showing that `Sleepers` is the movie that `user_1` is most likely to rate. In the example above we predicted the target node but we can also use the same mechanism to predict the source node. \n\nLet's turn that question around and say that we had a product and we wanted to find the people most likely to rate this product.\n\n## Predicting the top 10 users most likely to rate a movie\nTo accomplish this we would want to start at the movie vertex and predict the rated edge back to the user. Since we want to return the top 10 recommended users we need to use the `.with(\"Neptune#ml.limit\",10)` configuration option. Combining these together we get the query below which finds the top 10 users most likely to rate `Apollo 13`.", "_____no_output_____" ] ], [ [ "%%gremlin\ng.with(\"Neptune#ml.endpoint\",\"${endpoint}\").\n with(\"Neptune#ml.limit\",10).\n V().has('title', 'Apollo 13 (1995)').\n in('rated').with(\"Neptune#ml.prediction\").hasLabel('user').id()", "_____no_output_____" ] ], [ [ "With that we have sucessfully been able to show how you can use link prediction to predict edges starting at either end.", "_____no_output_____" ], [ "From the examples we have shown here you can begin to see how the ability to infer unknown connections within a graph starts to enable many interesting and unique use cases within Amazon Neptune. ", "_____no_output_____" ], [ "# Cleaning Up \nNow that you have completed this walkthrough you have created a Sagemaker endpoint which is currently running and will incur the standard charges. If you are done trying out Neptune ML and would like to avoid these recurring costs, run the cell below to delete the inference endpoint.", "_____no_output_____" ] ], [ [ "neptune_ml.delete_endpoint(training_job_name)", "_____no_output_____" ] ], [ [ "In addition to the inference endpoint the CloudFormation script that you used has setup several additional resources. If you are finished then we suggest you delete the CloudFormation stack to avoid any recurring charges. For instructions, see Deleting a Stack on the [Deleting a Stack on the Amazon Web Services CloudFormation Console](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-console-delete-stack.html). Be sure to delete the root stack (the stack you created earlier). Deleting the root stack deletes any nested stacks.", "_____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" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "empty" ] ] ]

[ "empty" ]

[ [ "empty" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "empty" ] ] ]

[ "empty" ]

[ [ "empty" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import pandas as pd\n\nfonte = \"https://github.com/alura-cursos/imersao-dados-2-2020/blob/master/MICRODADOS_ENEM_2019_SAMPLE_43278.csv?raw=true\"\n\n# Lendo banco de dados do ENEM 2019 (Amostra)\ndados = pd.read_csv(fonte)\ndados.shape", "_____no_output_____" ], [ "dados.head()", "_____no_output_____" ], [ "dados.columns.values", "_____no_output_____" ], [ "# Mostrando a 10 primeiras idades e seus totais de participantes em ordem crescente\ndados[ \"NU_IDADE\"].value_counts().sort_index().head(10)", "_____no_output_____" ] ], [ [ "Desafio01: Encontrar os valores relativos para as idades dos incritos\n\nDesafio02: Descobrir de quais estados são os inscritos com 13 anos.", "_____no_output_____" ], [ "Desafio03: Colocar título no gráfico", "_____no_output_____" ] ], [ [ "# Mostrando histograma das idades dos participantes\ndados[ \"NU_IDADE\"].hist(bins = 50, figsize = (16, 7))", "_____no_output_____" ], [ "# Fazendo query no bando de dados para pegar somente observacoes de treineiros, depois mostrando o total das idades em ordem crescente\ndados.query(\"IN_TREINEIRO == 1\")[\"NU_IDADE\"].value_counts().sort_index().head(5)", "_____no_output_____" ] ], [ [ "Desafio04: Plotar os histogramas das idades dos treineiros e não treineiros", "_____no_output_____" ] ], [ [ "# Plotando histograma das notas da redacao\ndados[\"NU_NOTA_REDACAO\"].hist(bins = 50, figsize=(19, 7))", "_____no_output_____" ], [ "# Plotando histograma das notas da prova de Ciências Humanas\ndados[\"NU_NOTA_CH\"].hist(bins = 50, figsize=(19, 7))", "_____no_output_____" ], [ "# Fazendo query no bando de dados para pegar somente observacoes do Estado de Minas\n# Depois separando somente as notas das provas \n# Por fim mostrando dados estatísticos\n\nprovas = [\"NU_NOTA_LC\", \"NU_NOTA_CH\", \"NU_NOTA_MT\", \"NU_NOTA_CN\", \"NU_NOTA_REDACAO\"]\ndados.query(\"SG_UF_RESIDENCIA == 'MG'\")[provas].describe()", "_____no_output_____" ], [ "# Fazendo query no bando de dados para pegar somente observacoes do Estado de Minas\n# Depois separando somente as notas das provas \n# Por fim plotando grafico boxplot contendo as notas das provas\n\nprovas = [\"NU_NOTA_LC\", \"NU_NOTA_CH\", \"NU_NOTA_MT\", \"NU_NOTA_CN\", \"NU_NOTA_REDACAO\"]\ndados.query(\"SG_UF_RESIDENCIA == 'MG'\")[provas].boxplot(grid = 1, figsize=(18,8))", "_____no_output_____" ] ], [ [ "Desafio05: Comparar as distribuições das provas em inglês e espanhol nas provas de LC", "_____no_output_____" ] ], [ [ "\n#Resolvendo desafio 01\n\ndados.query(\"NU_IDADE <= 14\")[\"SG_UF_RESIDENCIA\"].value_counts(normalize=True)", "_____no_output_____" ], [ "renda_ordenada = dados[\"Q006\"].unique()\nrenda_ordenada.sort()\nprint(renda_ordenada)\n", "['A' 'B' 'C' 'D' 'E' 'F' 'G' 'H' 'I' 'J' 'K' 'L' 'M' 'N' 'O' 'P' 'Q']\n" ], [ "import seaborn as sns\nimport matplotlib.pyplot as plt\n\nplt.figure(figsize=(18, 8))\nsns.boxplot(x=\"Q006\", y = \"NU_NOTA_REDACAO\", data = dados, order = renda_ordenada)\nplt.title(\"Boxplot das notas de matemática pela renda\")", "_____no_output_____" ], [ "total_notas_por_aluno = dados[provas].sum(axis=1)\ndados[\"NU_NOTA_TOTAL\"] = total_notas_por_aluno\ndados.head()", "_____no_output_____" ], [ "plt.figure(figsize=(18, 8))\ndados_sem_zeros = dados.query(\"NU_NOTA_TOTAL != 0\")\nsns.boxplot(x=\"Q006\", y = \"NU_NOTA_TOTAL\", data = dados_sem_zeros, order = renda_ordenada)\nplt.title(\"Boxplot das notas todais pela renda\")", "_____no_output_____" ], [ "sns.displot(dados, x = \"NU_NOTA_TOTAL\")", "_____no_output_____" ], [ "plt.figure(figsize=(18, 8))\nsns.boxplot(x=\"Q006\", y = \"NU_NOTA_TOTAL\", data = dados_sem_zeros, order = renda_ordenada, hue= \"IN_TREINEIRO\")\nplt.title(\"Boxplot das notas todais pela renda\")", "_____no_output_____" ], [ "", "_____no_output_____" ] ] ]

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

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

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "Nessie Iceberg/Flink SQL Demo with NBA Dataset\n============================\nThis demo showcases how to use Nessie Python API along with Flink from Iceberg\n\nInitialize PyFlink\n----------------------------------------------\nTo get started, we will first have to do a few setup steps that give us everything we need\nto get started with Nessie. In case you're interested in the detailed setup steps for Flink, you can check out the [docs](https://projectnessie.org/tools/flink/)\n\nThe Binder server has downloaded flink and some data for us as well as started a Nessie server in the background. All we have to do is start Flink\n\nThe below cell starts a local Flink session with parameters needed to configure Nessie. Each config option is followed by a comment explaining its purpose.\n", "_____no_output_____" ] ], [ [ "import os\nfrom pyflink.datastream import StreamExecutionEnvironment\nfrom pyflink.table import StreamTableEnvironment\nfrom pyflink.table.expressions import lit\nfrom pynessie import init\n\n# where we will store our data\nwarehouse = os.path.join(os.getcwd(), \"flink-warehouse\")\n# this was downloaded when Binder started, its available on maven central\niceberg_flink_runtime_jar = os.path.join(os.getcwd(), \"../iceberg-flink-runtime-0.12.0.jar\")\n\nenv = StreamExecutionEnvironment.get_execution_environment()\nenv.add_jars(\"file://{}\".format(iceberg_flink_runtime_jar))\ntable_env = StreamTableEnvironment.create(env)\n\nnessie_client = init()\n\ndef create_ref_catalog(ref):\n \"\"\"\n Create a flink catalog that is tied to a specific ref.\n\n In order to create the catalog we have to first create the branch\n \"\"\"\n hash_ = nessie_client.get_reference(nessie_client.get_default_branch()).hash_\n try:\n nessie_client.create_branch(ref, hash_)\n except:\n pass # already created\n # The important args below are:\n # type: tell Flink to use Iceberg as the catalog\n # catalog-impl: which Iceberg catalog to use, in this case we want Nessie\n # uri: the location of the nessie server.\n # ref: the Nessie ref/branch we want to use (defaults to main)\n # warehouse: the location this catalog should store its data\n table_env.execute_sql(\n f\"\"\"CREATE CATALOG {ref}_catalog WITH (\n 'type'='iceberg',\n 'catalog-impl'='org.apache.iceberg.nessie.NessieCatalog',\n 'uri'='http://localhost:19120/api/v1',\n 'ref'='{ref}',\n 'warehouse' = '{warehouse}')\"\"\"\n )\ncreate_ref_catalog(nessie_client.get_default_branch())\nprint(\"\\n\\n\\nFlink running\\n\\n\\n\")", "_____no_output_____" ] ], [ [ "Solving Data Engineering problems with Nessie\n============================\n\nIn this Demo we are a data engineer working at a fictional sports analytics blog. In order for the authors to write articles they have to have access to the relevant data. They need to be able to retrieve data quickly and be able to create charts with it.\n\nWe have been asked to collect and expose some information about basketball players. We have located some data sources and are now ready to start ingesting data into our data lakehouse. We will perform the ingestion steps on a Nessie branch to test and validate the data before exposing to the analysts.", "_____no_output_____" ], [ "Set up Nessie branches (via Nessie CLI)\n----------------------------\nOnce all dependencies are configured, we can get started with ingesting our basketball data into `Nessie` with the following steps:\n\n- Create a new branch named `dev`\n- List all branches\n\nIt is worth mentioning that we don't have to explicitly create a `main` branch, since it's the default branch.", "_____no_output_____" ] ], [ [ "create_ref_catalog(\"dev\")", "_____no_output_____" ] ], [ [ "We have created the branch `dev` and we can see the branch with the Nessie `hash` its currently pointing to.\n\nBelow we list all branches. Note that the auto created `main` branch already exists and both branches point at the same `hash`", "_____no_output_____" ] ], [ [ "!nessie --verbose branch", "_____no_output_____" ] ], [ [ "Create tables under dev branch\n-------------------------------------\nOnce we created the `dev` branch and verified that it exists, we can create some tables and add some data.\n\nWe create two tables under the `dev` branch:\n- `salaries`\n- `totals_stats`\n\nThese tables list the salaries per player per year and their stats per year.\n\nTo create the data we:\n\n1. switch our branch context to dev\n2. create the table\n3. insert the data from an existing csv file. This csv file is already stored locally on the demo machine. A production use case would likely take feeds from official data sources\n", "_____no_output_____" ] ], [ [ "# Load the dataset\nfrom pyflink.table import DataTypes\nfrom pyflink.table.descriptors import Schema, OldCsv, FileSystem\n\n# Creating `salaries` table\n(table_env.connect(FileSystem().path('../datasets/nba/salaries.csv'))\n .with_format(OldCsv()\n .field('Season', DataTypes.STRING()).field(\"Team\", DataTypes.STRING())\n .field(\"Salary\", DataTypes.STRING()).field(\"Player\", DataTypes.STRING()))\n .with_schema(Schema()\n .field('Season', DataTypes.STRING()).field(\"Team\", DataTypes.STRING())\n .field(\"Salary\", DataTypes.STRING()).field(\"Player\", DataTypes.STRING()))\n .create_temporary_table('dev_catalog.nba.salaries_temp'))\n\ntable_env.execute_sql(\"\"\"CREATE TABLE IF NOT EXISTS dev_catalog.nba.salaries\n (Season STRING, Team STRING, Salary STRING, Player STRING)\"\"\").wait()\n\ntab = table_env.from_path('dev_catalog.nba.salaries_temp')\ntab.execute_insert('dev_catalog.nba.salaries').wait()\n\n# Creating `totals_stats` table\n(table_env.connect(FileSystem().path('../datasets/nba/totals_stats.csv'))\n .with_format(OldCsv()\n .field('Season', DataTypes.STRING()).field(\"Age\", DataTypes.STRING()).field(\"Team\", DataTypes.STRING())\n .field(\"ORB\", DataTypes.STRING()).field(\"DRB\", DataTypes.STRING()).field(\"TRB\", DataTypes.STRING())\n .field(\"AST\", DataTypes.STRING()).field(\"STL\", DataTypes.STRING()).field(\"BLK\", DataTypes.STRING())\n .field(\"TOV\", DataTypes.STRING()).field(\"PTS\", DataTypes.STRING()).field(\"Player\", DataTypes.STRING())\n .field(\"RSorPO\", DataTypes.STRING()))\n .with_schema(Schema()\n .field('Season', DataTypes.STRING()).field(\"Age\", DataTypes.STRING()).field(\"Team\", DataTypes.STRING())\n .field(\"ORB\", DataTypes.STRING()).field(\"DRB\", DataTypes.STRING()).field(\"TRB\", DataTypes.STRING())\n .field(\"AST\", DataTypes.STRING()).field(\"STL\", DataTypes.STRING()).field(\"BLK\", DataTypes.STRING())\n .field(\"TOV\", DataTypes.STRING()).field(\"PTS\", DataTypes.STRING()).field(\"Player\", DataTypes.STRING())\n .field(\"RSorPO\", DataTypes.STRING()))\n .create_temporary_table('dev_catalog.nba.totals_stats_temp'))\n\ntable_env.execute_sql(\n \"\"\"CREATE TABLE IF NOT EXISTS dev_catalog.nba.totals_stats (Season STRING, Age STRING, Team STRING,\n ORB STRING, DRB STRING, TRB STRING, AST STRING, STL STRING, BLK STRING, TOV STRING, PTS STRING,\n Player STRING, RSorPO STRING)\"\"\").wait()\n\ntab = table_env.from_path('dev_catalog.nba.totals_stats_temp')\ntab.execute_insert('dev_catalog.nba.totals_stats').wait()\n\nsalaries = table_env.from_path('main_catalog.nba.`salaries@dev`').select(lit(1).count).to_pandas().values[0][0]\ntotals_stats = table_env.from_path('main_catalog.nba.`totals_stats@dev`').select(lit(1).count).to_pandas().values[0][0]\nprint(f\"\\n\\n\\nAdded {salaries} rows to the salaries table and {totals_stats} rows to the total_stats table.\\n\\n\\n\")", "_____no_output_____" ] ], [ [ "Now we count the rows in our tables to ensure they are the same number as the csv files. Note we use the `table@branch` notation which overrides the context set by the catalog.", "_____no_output_____" ] ], [ [ "table_count = table_env.from_path('dev_catalog.nba.`salaries@dev`').select('Season.count').to_pandas().values[0][0]\ncsv_count = table_env.from_path('dev_catalog.nba.salaries_temp').select('Season.count').to_pandas().values[0][0]\nassert table_count == csv_count\nprint(table_count)\n\ntable_count = table_env.from_path('dev_catalog.nba.`totals_stats@dev`').select('Season.count').to_pandas().values[0][0]\ncsv_count = table_env.from_path('dev_catalog.nba.totals_stats_temp').select('Season.count').to_pandas().values[0][0]\nassert table_count == csv_count\nprint(table_count)", "_____no_output_____" ] ], [ [ "Check generated tables\n----------------------------\nSince we have been working solely on the `dev` branch, where we created 2 tables and added some data,\nlet's verify that the `main` branch was not altered by our changes.", "_____no_output_____" ] ], [ [ "!nessie contents --list", "_____no_output_____" ] ], [ [ "And on the `dev` branch we expect to see two tables", "_____no_output_____" ] ], [ [ "!nessie contents --list --ref dev", "_____no_output_____" ] ], [ [ "We can also verify that the `dev` and `main` branches point to different commits", "_____no_output_____" ] ], [ [ "!nessie --verbose branch", "_____no_output_____" ] ], [ [ "Dev promotion into main\n-----------------------\nOnce we are done with our changes on the `dev` branch, we would like to merge those changes into `main`.\nWe merge `dev` into `main` via the command line `merge` command.\nBoth branches should be at the same revision after merging/promotion.", "_____no_output_____" ] ], [ [ "!nessie merge dev -b main --force", "_____no_output_____" ] ], [ [ "We can verify the branches are at the same hash and that the `main` branch now contains the expected tables and row counts.\n\nThe tables are now on `main` and ready for consumtion by our blog authors and analysts!", "_____no_output_____" ] ], [ [ "!nessie --verbose branch", "_____no_output_____" ], [ "!nessie contents --list", "_____no_output_____" ], [ "table_count = table_env.from_path('main_catalog.nba.salaries').select('Season.count').to_pandas().values[0][0]\ncsv_count = table_env.from_path('dev_catalog.nba.salaries_temp').select('Season.count').to_pandas().values[0][0]\nassert table_count == csv_count\n\ntable_count = table_env.from_path('main_catalog.nba.totals_stats').select('Season.count').to_pandas().values[0][0]\ncsv_count = table_env.from_path('dev_catalog.nba.totals_stats_temp').select('Season.count').to_pandas().values[0][0]\nassert table_count == csv_count", "_____no_output_____" ] ], [ [ "Perform regular ETL on the new tables\n-------------------\nOur analysts are happy with the data and we want to now regularly ingest data to keep things up to date. Our first ETL job consists of the following:\n\n1. Update the salaries table to add new data\n2. We have decided the `Age` column isn't required in the `total_stats` table so we will drop the column\n3. We create a new table to hold information about the players appearances in all star games\n\nAs always we will do this work on a branch and verify the results. This ETL job can then be set up to run nightly with new stats and salary information.", "_____no_output_____" ] ], [ [ "create_ref_catalog(\"etl\")", "_____no_output_____" ], [ "# add some salaries for Kevin Durant\ntable_env.execute_sql(\"\"\"INSERT INTO etl_catalog.nba.salaries\n VALUES ('2017-18', 'Golden State Warriors', '$25000000', 'Kevin Durant'),\n ('2018-19', 'Golden State Warriors', '$30000000', 'Kevin Durant'),\n ('2019-20', 'Brooklyn Nets', '$37199000', 'Kevin Durant'),\n ('2020-21', 'Brooklyn Nets', '$39058950', 'Kevin Durant')\"\"\").wait()", "_____no_output_____" ], [ "# Rename the table `totals_stats` to `new_total_stats`\ntable_env.execute_sql(\"ALTER TABLE etl_catalog.nba.totals_stats RENAME TO etl_catalog.nba.new_total_stats\").wait()", "_____no_output_____" ], [ "# Creating `allstar_games_stats` table\n(table_env.connect(FileSystem().path('../datasets/nba/allstar_games_stats.csv'))\n .with_format(OldCsv()\n .field('Season', DataTypes.STRING()).field(\"Age\", DataTypes.STRING()).field(\"Team\", DataTypes.STRING())\n .field(\"ORB\", DataTypes.STRING()).field(\"TRB\", DataTypes.STRING()).field(\"AST\", DataTypes.STRING())\n .field(\"STL\", DataTypes.STRING()).field(\"BLK\", DataTypes.STRING()).field(\"TOV\", DataTypes.STRING())\n .field(\"PF\", DataTypes.STRING()).field(\"PTS\", DataTypes.STRING()).field(\"Player\", DataTypes.STRING()))\n .with_schema(Schema()\n .field('Season', DataTypes.STRING()).field(\"Age\", DataTypes.STRING()).field(\"Team\", DataTypes.STRING())\n .field(\"ORB\", DataTypes.STRING()).field(\"TRB\", DataTypes.STRING()).field(\"AST\", DataTypes.STRING())\n .field(\"STL\", DataTypes.STRING()).field(\"BLK\", DataTypes.STRING()).field(\"TOV\", DataTypes.STRING())\n .field(\"PF\", DataTypes.STRING()).field(\"PTS\", DataTypes.STRING()).field(\"Player\", DataTypes.STRING()))\n .create_temporary_table('etl_catalog.nba.allstar_games_stats_temp'))\n\ntable_env.execute_sql(\n \"\"\"CREATE TABLE IF NOT EXISTS etl_catalog.nba.allstar_games_stats (Season STRING, Age STRING,\n Team STRING, ORB STRING, TRB STRING, AST STRING, STL STRING, BLK STRING, TOV STRING,\n PF STRING, PTS STRING, Player STRING)\"\"\").wait()\n\ntab = table_env.from_path('etl_catalog.nba.allstar_games_stats_temp')\ntab.execute_insert('etl_catalog.nba.allstar_games_stats').wait()\n\n# Notice how we view the data on the etl branch via @etl\ntable_env.from_path('etl_catalog.nba.`allstar_games_stats@etl`').to_pandas()", "_____no_output_____" ] ], [ [ "We can verify that the new table isn't on the `main` branch but is present on the etl branch", "_____no_output_____" ] ], [ [ "# Since we have been working on the `etl` branch, the `allstar_games_stats` table is not on the `main` branch\n!nessie contents --list", "_____no_output_____" ], [ "# We should see `allstar_games_stats` and the `new_total_stats` on the `etl` branch\n!nessie contents --list --ref etl", "_____no_output_____" ] ], [ [ "Now that we are happy with the data we can again merge it into `main`", "_____no_output_____" ] ], [ [ "!nessie merge etl -b main --force", "_____no_output_____" ] ], [ [ "Now lets verify that the changes exist on the `main` branch and that the `main` and `etl` branches have the same `hash`", "_____no_output_____" ] ], [ [ "!nessie contents --list", "_____no_output_____" ], [ "!nessie --verbose branch", "_____no_output_____" ], [ "table_count = table_env.from_path('main_catalog.nba.allstar_games_stats').select('Season.count').to_pandas().values[0][0]\ncsv_count = table_env.from_path('etl_catalog.nba.allstar_games_stats_temp').select('Season.count').to_pandas().values[0][0]\nassert table_count == csv_count", "_____no_output_____" ] ], [ [ "Create `experiment` branch\n--------------------------------\nAs a data analyst we might want to carry out some experiments with some data, without affecting `main` in any way.\nAs in the previous examples, we can just get started by creating an `experiment` branch off of `main`\nand carry out our experiment, which could consist of the following steps:\n- drop `totals_stats` table\n- add data to `salaries` table\n- compare `experiment` and `main` tables", "_____no_output_____" ] ], [ [ "create_ref_catalog(\"experiment\")", "_____no_output_____" ], [ "# Drop the `totals_stats` table on the `experiment` branch\ntable_env.execute_sql(\"DROP TABLE IF EXISTS experiment_catalog.nba.new_total_stats\")", "_____no_output_____" ], [ "# add some salaries for Dirk Nowitzki\ntable_env.execute_sql(\"\"\"INSERT INTO experiment_catalog.nba.salaries VALUES\n ('2015-16', 'Dallas Mavericks', '$8333333', 'Dirk Nowitzki'),\n ('2016-17', 'Dallas Mavericks', '$25000000', 'Dirk Nowitzki'),\n ('2017-18', 'Dallas Mavericks', '$5000000', 'Dirk Nowitzki'),\n ('2018-19', 'Dallas Mavericks', '$5000000', 'Dirk Nowitzki')\"\"\").wait()", "_____no_output_____" ], [ "# We should see the `salaries` and `allstar_games_stats` tables only (since we just dropped `new_total_stats`)\n!nessie contents --list --ref experiment", "_____no_output_____" ], [ "# `main` hasn't changed been changed and still has the `new_total_stats` table\n!nessie contents --list", "_____no_output_____" ] ], [ [ "Let's take a look at the contents of the `salaries` table on the `experiment` branch.\nNotice the use of the `nessie` catalog and the use of `@experiment` to view data on the `experiment` branch", "_____no_output_____" ] ], [ [ "table_env.from_path('main_catalog.nba.`salaries@experiment`').select(lit(1).count).to_pandas()", "_____no_output_____" ] ], [ [ "and compare to the contents of the `salaries` table on the `main` branch. Notice that we didn't have to specify `@branchName` as it defaulted\nto the `main` branch", "_____no_output_____" ] ], [ [ "table_env.from_path('main_catalog.nba.`salaries@main`').select(lit(1).count).to_pandas()\n", "_____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" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "import tensorflow as tf", "_____no_output_____" ], [ "(x_train, y_train), (x_test, y_test) = tf.keras.datasets.reuters.load_data(num_words=10000)\nx_train.shape, y_train.shape, x_test.shape, y_test.shape", "Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/reuters.npz\n2113536/2110848 [==============================] - 0s 0us/step\n" ], [ "print(y_train[50], x_train[50])", "4 [1, 1479, 1197, 71, 8, 25, 1479, 1197, 640, 71, 304, 471, 80, 9, 1379, 1901, 4530, 6797, 79, 5, 8144, 71, 175, 80, 58, 4, 1279, 5, 63, 32, 20, 5, 4, 326, 175, 80, 335, 7, 10, 845, 31, 4, 221, 9, 108, 259, 1479, 1197, 640, 8, 16, 600, 69, 68, 11, 15, 6, 8144, 21, 397, 321, 6, 438, 1761, 3072, 79, 5, 8144, 1040, 894, 1051, 617, 80, 4, 617, 80, 23, 1051, 172, 3814, 3206, 8144, 175, 79, 9, 1379, 6, 264, 395, 3814, 3206, 79, 1479, 1197, 9, 25, 323, 8, 4, 8144, 80, 23, 381, 43, 42, 205, 50, 77, 33, 909, 9, 3509, 22, 216, 6, 216, 17, 12]\n" ], [ "len(x_train[50]), len(x_train[400])", "_____no_output_____" ], [ "pad_x_train = tf.keras.preprocessing.sequence.pad_sequences(x_train, maxlen=500)\nlen(pad_x_train[50])", "_____no_output_____" ], [ "import numpy as np\nnp.unique(y_train)", "_____no_output_____" ] ], [ [ "# Make model", "_____no_output_____" ] ], [ [ "model = tf.keras.models.Sequential()", "_____no_output_____" ], [ "model.add(tf.keras.layers.Embedding(input_length=500, input_dim=10000, output_dim=24)) # input layer\nmodel.add(tf.keras.layers.LSTM(24, return_sequences=True, activation='tanh')) # LSTM을 하나 더 쓸 때\nmodel.add(tf.keras.layers.LSTM(12, activation='tanh'))\n# model.add(tf.keras.layers.Flatten()) # hidden layer\nmodel.add(tf.keras.layers.Dense(46, activation='softmax')) # output layer\n\nmodel.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['acc']) # gadget", "_____no_output_____" ], [ "# hist = model.fit(pad_x_train, y_train, epochs=5, validation_split=0.3, batch_size=128)\nhist = model.fit(pad_x_train, y_train, epochs=100, validation_split=0.3, batch_size=256)", "Epoch 1/100\n25/25 [==============================] - 20s 658ms/step - loss: 3.7195 - acc: 0.2704 - val_loss: 3.4674 - val_acc: 0.0479\nEpoch 2/100\n25/25 [==============================] - 16s 627ms/step - loss: 3.2134 - acc: 0.2591 - val_loss: 2.9466 - val_acc: 0.3532\nEpoch 3/100\n25/25 [==============================] - 16s 638ms/step - loss: 2.7723 - acc: 0.3510 - val_loss: 2.5808 - val_acc: 0.3532\nEpoch 4/100\n25/25 [==============================] - 16s 629ms/step - loss: 2.5263 - acc: 0.3510 - val_loss: 2.4439 - val_acc: 0.3532\nEpoch 5/100\n25/25 [==============================] - 16s 624ms/step - loss: 2.4537 - acc: 0.3510 - val_loss: 2.4077 - val_acc: 0.3532\nEpoch 6/100\n25/25 [==============================] - 16s 635ms/step - loss: 2.4323 - acc: 0.3510 - val_loss: 2.3950 - val_acc: 0.3532\nEpoch 7/100\n25/25 [==============================] - 16s 638ms/step - loss: 2.4233 - acc: 0.3510 - val_loss: 2.3891 - val_acc: 0.3532\nEpoch 8/100\n25/25 [==============================] - 16s 642ms/step - loss: 2.4190 - acc: 0.3510 - val_loss: 2.3863 - val_acc: 0.3532\nEpoch 9/100\n25/25 [==============================] - 16s 642ms/step - loss: 2.4164 - acc: 0.3510 - val_loss: 2.3847 - val_acc: 0.3532\nEpoch 10/100\n25/25 [==============================] - 16s 639ms/step - loss: 2.4149 - acc: 0.3510 - val_loss: 2.3839 - val_acc: 0.3532\nEpoch 11/100\n25/25 [==============================] - 16s 636ms/step - loss: 2.4139 - acc: 0.3510 - val_loss: 2.3833 - val_acc: 0.3532\nEpoch 12/100\n25/25 [==============================] - 16s 636ms/step - loss: 2.4133 - acc: 0.3510 - val_loss: 2.3826 - val_acc: 0.3532\nEpoch 13/100\n25/25 [==============================] - 16s 649ms/step - loss: 2.4129 - acc: 0.3510 - val_loss: 2.3823 - val_acc: 0.3532\nEpoch 14/100\n25/25 [==============================] - 16s 635ms/step - loss: 2.4126 - acc: 0.3510 - val_loss: 2.3825 - val_acc: 0.3532\nEpoch 15/100\n25/25 [==============================] - 16s 641ms/step - loss: 2.4122 - acc: 0.3510 - val_loss: 2.3821 - val_acc: 0.3532\nEpoch 16/100\n25/25 [==============================] - 16s 644ms/step - loss: 2.4123 - acc: 0.3510 - val_loss: 2.3820 - val_acc: 0.3532\nEpoch 17/100\n25/25 [==============================] - 16s 641ms/step - loss: 2.4119 - acc: 0.3510 - val_loss: 2.3822 - val_acc: 0.3532\nEpoch 18/100\n25/25 [==============================] - 16s 636ms/step - loss: 2.4120 - acc: 0.3510 - val_loss: 2.3825 - val_acc: 0.3532\nEpoch 19/100\n25/25 [==============================] - 16s 633ms/step - loss: 2.4120 - acc: 0.3510 - val_loss: 2.3822 - val_acc: 0.3532\nEpoch 20/100\n25/25 [==============================] - 16s 644ms/step - loss: 2.4117 - acc: 0.3510 - val_loss: 2.3823 - val_acc: 0.3532\nEpoch 21/100\n25/25 [==============================] - 16s 634ms/step - loss: 2.4119 - acc: 0.3510 - val_loss: 2.3819 - val_acc: 0.3532\nEpoch 22/100\n25/25 [==============================] - 16s 632ms/step - loss: 2.4115 - acc: 0.3510 - val_loss: 2.3821 - val_acc: 0.3532\nEpoch 23/100\n25/25 [==============================] - 16s 635ms/step - loss: 2.4119 - acc: 0.3510 - val_loss: 2.3825 - val_acc: 0.3532\nEpoch 24/100\n25/25 [==============================] - 16s 641ms/step - loss: 2.4115 - acc: 0.3510 - val_loss: 2.3819 - val_acc: 0.3532\nEpoch 25/100\n25/25 [==============================] - 16s 642ms/step - loss: 2.4029 - acc: 0.3510 - val_loss: 2.4550 - val_acc: 0.3532\nEpoch 26/100\n25/25 [==============================] - 16s 651ms/step - loss: 2.4105 - acc: 0.3510 - val_loss: 2.3819 - val_acc: 0.3532\nEpoch 27/100\n25/25 [==============================] - 16s 641ms/step - loss: 2.4118 - acc: 0.3510 - val_loss: 2.3822 - val_acc: 0.3532\nEpoch 28/100\n25/25 [==============================] - 16s 635ms/step - loss: 2.4118 - acc: 0.3510 - val_loss: 2.3823 - val_acc: 0.3532\nEpoch 29/100\n25/25 [==============================] - 16s 639ms/step - loss: 2.4116 - acc: 0.3510 - val_loss: 2.3823 - val_acc: 0.3532\nEpoch 30/100\n25/25 [==============================] - 16s 642ms/step - loss: 2.4114 - acc: 0.3510 - val_loss: 2.3824 - val_acc: 0.3532\nEpoch 31/100\n25/25 [==============================] - 16s 644ms/step - loss: 2.4117 - acc: 0.3510 - val_loss: 2.3823 - val_acc: 0.3532\nEpoch 32/100\n25/25 [==============================] - 16s 641ms/step - loss: 2.4118 - acc: 0.3510 - val_loss: 2.3824 - val_acc: 0.3532\nEpoch 33/100\n25/25 [==============================] - 16s 648ms/step - loss: 2.4116 - acc: 0.3510 - val_loss: 2.3824 - val_acc: 0.3532\nEpoch 34/100\n25/25 [==============================] - 16s 643ms/step - loss: 2.4115 - acc: 0.3510 - val_loss: 2.3821 - val_acc: 0.3532\nEpoch 35/100\n25/25 [==============================] - 16s 641ms/step - loss: 2.4116 - acc: 0.3510 - val_loss: 2.3825 - val_acc: 0.3532\nEpoch 36/100\n25/25 [==============================] - 16s 640ms/step - loss: 2.4116 - acc: 0.3510 - val_loss: 2.3824 - val_acc: 0.3532\nEpoch 37/100\n25/25 [==============================] - 16s 644ms/step - loss: 2.4117 - acc: 0.3510 - val_loss: 2.3824 - val_acc: 0.3532\nEpoch 38/100\n25/25 [==============================] - 16s 647ms/step - loss: 2.4117 - acc: 0.3510 - val_loss: 2.3825 - val_acc: 0.3532\nEpoch 39/100\n25/25 [==============================] - 16s 633ms/step - loss: 2.4116 - acc: 0.3510 - val_loss: 2.3826 - val_acc: 0.3532\nEpoch 40/100\n25/25 [==============================] - 16s 636ms/step - loss: 2.4116 - acc: 0.3510 - val_loss: 2.3822 - val_acc: 0.3532\nEpoch 41/100\n25/25 [==============================] - 16s 639ms/step - loss: 2.4115 - acc: 0.3510 - val_loss: 2.3820 - val_acc: 0.3532\nEpoch 42/100\n25/25 [==============================] - 16s 640ms/step - loss: 2.4122 - acc: 0.3510 - val_loss: 2.3825 - val_acc: 0.3532\nEpoch 43/100\n25/25 [==============================] - 16s 643ms/step - loss: 2.4118 - acc: 0.3510 - val_loss: 2.3822 - val_acc: 0.3532\nEpoch 44/100\n25/25 [==============================] - 16s 638ms/step - loss: 2.4118 - acc: 0.3510 - val_loss: 2.3825 - val_acc: 0.3532\nEpoch 45/100\n25/25 [==============================] - 16s 638ms/step - loss: 2.4116 - acc: 0.3510 - val_loss: 2.3825 - val_acc: 0.3532\nEpoch 46/100\n25/25 [==============================] - 16s 636ms/step - loss: 2.4118 - acc: 0.3510 - val_loss: 2.3823 - val_acc: 0.3532\nEpoch 47/100\n25/25 [==============================] - 16s 643ms/step - loss: 2.4116 - acc: 0.3510 - val_loss: 2.3824 - val_acc: 0.3532\nEpoch 48/100\n25/25 [==============================] - 16s 638ms/step - loss: 2.4119 - acc: 0.3510 - val_loss: 2.3823 - val_acc: 0.3532\nEpoch 49/100\n25/25 [==============================] - 16s 638ms/step - loss: 2.4117 - acc: 0.3510 - val_loss: 2.3824 - val_acc: 0.3532\nEpoch 50/100\n25/25 [==============================] - 16s 641ms/step - loss: 2.4115 - acc: 0.3510 - val_loss: 2.3824 - val_acc: 0.3532\nEpoch 51/100\n25/25 [==============================] - 16s 637ms/step - loss: 2.4115 - acc: 0.3510 - val_loss: 2.3820 - val_acc: 0.3532\nEpoch 52/100\n25/25 [==============================] - 16s 634ms/step - loss: 2.4115 - acc: 0.3510 - val_loss: 2.3822 - val_acc: 0.3532\nEpoch 53/100\n25/25 [==============================] - 16s 642ms/step - loss: 2.4104 - acc: 0.3510 - val_loss: 2.3803 - val_acc: 0.3532\nEpoch 54/100\n25/25 [==============================] - 16s 645ms/step - loss: 2.4060 - acc: 0.3510 - val_loss: 2.3665 - val_acc: 0.3532\nEpoch 55/100\n25/25 [==============================] - 16s 639ms/step - loss: 2.3382 - acc: 0.3755 - val_loss: 2.2555 - val_acc: 0.4764\nEpoch 56/100\n25/25 [==============================] - 16s 648ms/step - loss: 2.2553 - acc: 0.3689 - val_loss: 2.1948 - val_acc: 0.4553\nEpoch 57/100\n25/25 [==============================] - 16s 644ms/step - loss: 2.1991 - acc: 0.4641 - val_loss: 2.1491 - val_acc: 0.4842\nEpoch 58/100\n25/25 [==============================] - 16s 644ms/step - loss: 2.1441 - acc: 0.5096 - val_loss: 2.0970 - val_acc: 0.5239\nEpoch 59/100\n25/25 [==============================] - 16s 644ms/step - loss: 2.0953 - acc: 0.5254 - val_loss: 2.0584 - val_acc: 0.5288\nEpoch 60/100\n25/25 [==============================] - 16s 639ms/step - loss: 2.0709 - acc: 0.5160 - val_loss: 2.0558 - val_acc: 0.5006\nEpoch 61/100\n25/25 [==============================] - 16s 642ms/step - loss: 2.0219 - acc: 0.5340 - val_loss: 2.0104 - val_acc: 0.5276\nEpoch 62/100\n25/25 [==============================] - 16s 641ms/step - loss: 1.9885 - acc: 0.5398 - val_loss: 1.9924 - val_acc: 0.5187\nEpoch 63/100\n25/25 [==============================] - 16s 632ms/step - loss: 1.9596 - acc: 0.5397 - val_loss: 1.9764 - val_acc: 0.5165\nEpoch 64/100\n25/25 [==============================] - 16s 631ms/step - loss: 1.9213 - acc: 0.5418 - val_loss: 1.9706 - val_acc: 0.5132\nEpoch 65/100\n25/25 [==============================] - 16s 629ms/step - loss: 1.8728 - acc: 0.5379 - val_loss: 1.9073 - val_acc: 0.4994\nEpoch 66/100\n25/25 [==============================] - 16s 643ms/step - loss: 1.7927 - acc: 0.5683 - val_loss: 1.8431 - val_acc: 0.5299\nEpoch 67/100\n25/25 [==============================] - 16s 640ms/step - loss: 1.7446 - acc: 0.5780 - val_loss: 1.8360 - val_acc: 0.5273\nEpoch 68/100\n25/25 [==============================] - 16s 642ms/step - loss: 1.6942 - acc: 0.5825 - val_loss: 1.8078 - val_acc: 0.5351\nEpoch 69/100\n25/25 [==============================] - 16s 636ms/step - loss: 1.6616 - acc: 0.5858 - val_loss: 1.8114 - val_acc: 0.5310\nEpoch 70/100\n25/25 [==============================] - 16s 647ms/step - loss: 1.6356 - acc: 0.5925 - val_loss: 1.7646 - val_acc: 0.5432\nEpoch 71/100\n25/25 [==============================] - 16s 652ms/step - loss: 1.5982 - acc: 0.6039 - val_loss: 1.7583 - val_acc: 0.5518\nEpoch 72/100\n25/25 [==============================] - 16s 648ms/step - loss: 1.5679 - acc: 0.6122 - val_loss: 1.7503 - val_acc: 0.5570\nEpoch 73/100\n25/25 [==============================] - 16s 653ms/step - loss: 1.5409 - acc: 0.6176 - val_loss: 1.7591 - val_acc: 0.5518\nEpoch 74/100\n25/25 [==============================] - 16s 652ms/step - loss: 1.5137 - acc: 0.6218 - val_loss: 1.7479 - val_acc: 0.5555\nEpoch 75/100\n25/25 [==============================] - 16s 646ms/step - loss: 1.4868 - acc: 0.6268 - val_loss: 1.7797 - val_acc: 0.5466\nEpoch 76/100\n25/25 [==============================] - 16s 643ms/step - loss: 1.4703 - acc: 0.6267 - val_loss: 1.7516 - val_acc: 0.5525\nEpoch 77/100\n25/25 [==============================] - 16s 649ms/step - loss: 1.4460 - acc: 0.6275 - val_loss: 1.7809 - val_acc: 0.5391\nEpoch 78/100\n25/25 [==============================] - 16s 648ms/step - loss: 1.4209 - acc: 0.6310 - val_loss: 1.7754 - val_acc: 0.5484\nEpoch 79/100\n25/25 [==============================] - 16s 652ms/step - loss: 1.4056 - acc: 0.6289 - val_loss: 1.7807 - val_acc: 0.5451\nEpoch 80/100\n25/25 [==============================] - 16s 648ms/step - loss: 1.3871 - acc: 0.6350 - val_loss: 1.7988 - val_acc: 0.5406\nEpoch 81/100\n25/25 [==============================] - 16s 650ms/step - loss: 1.3677 - acc: 0.6361 - val_loss: 1.7908 - val_acc: 0.5488\nEpoch 82/100\n25/25 [==============================] - 16s 651ms/step - loss: 1.3643 - acc: 0.6350 - val_loss: 1.8382 - val_acc: 0.5317\nEpoch 83/100\n25/25 [==============================] - 16s 643ms/step - loss: 1.3414 - acc: 0.6434 - val_loss: 1.7929 - val_acc: 0.5492\nEpoch 84/100\n25/25 [==============================] - 16s 646ms/step - loss: 1.3253 - acc: 0.6472 - val_loss: 1.8259 - val_acc: 0.5440\nEpoch 85/100\n25/25 [==============================] - 16s 654ms/step - loss: 1.3071 - acc: 0.6485 - val_loss: 1.8041 - val_acc: 0.5462\nEpoch 86/100\n25/25 [==============================] - 16s 644ms/step - loss: 1.2946 - acc: 0.6626 - val_loss: 1.8500 - val_acc: 0.5310\nEpoch 87/100\n25/25 [==============================] - 16s 644ms/step - loss: 1.2779 - acc: 0.6706 - val_loss: 1.8331 - val_acc: 0.5347\nEpoch 88/100\n25/25 [==============================] - 16s 640ms/step - loss: 1.2590 - acc: 0.6841 - val_loss: 1.8651 - val_acc: 0.5291\nEpoch 89/100\n25/25 [==============================] - 16s 639ms/step - loss: 1.2441 - acc: 0.6909 - val_loss: 1.8525 - val_acc: 0.5358\nEpoch 90/100\n25/25 [==============================] - 16s 645ms/step - loss: 1.2360 - acc: 0.6811 - val_loss: 1.8554 - val_acc: 0.5380\nEpoch 91/100\n25/25 [==============================] - 16s 634ms/step - loss: 1.2183 - acc: 0.6847 - val_loss: 1.8912 - val_acc: 0.5295\nEpoch 92/100\n25/25 [==============================] - 16s 640ms/step - loss: 1.2373 - acc: 0.6703 - val_loss: 1.8739 - val_acc: 0.5336\nEpoch 93/100\n25/25 [==============================] - 16s 643ms/step - loss: 1.1995 - acc: 0.6854 - val_loss: 1.9008 - val_acc: 0.5302\nEpoch 94/100\n25/25 [==============================] - 16s 636ms/step - loss: 1.1730 - acc: 0.6878 - val_loss: 1.8738 - val_acc: 0.5362\nEpoch 95/100\n25/25 [==============================] - 16s 640ms/step - loss: 1.1558 - acc: 0.6911 - val_loss: 1.9222 - val_acc: 0.5147\nEpoch 96/100\n25/25 [==============================] - 16s 638ms/step - loss: 1.1452 - acc: 0.6917 - val_loss: 1.9129 - val_acc: 0.5280\nEpoch 97/100\n25/25 [==============================] - 16s 640ms/step - loss: 1.1313 - acc: 0.6954 - val_loss: 1.8829 - val_acc: 0.5384\nEpoch 98/100\n25/25 [==============================] - 16s 641ms/step - loss: 1.1093 - acc: 0.6975 - val_loss: 1.9224 - val_acc: 0.5250\nEpoch 99/100\n25/25 [==============================] - 16s 640ms/step - loss: 1.0904 - acc: 0.7040 - val_loss: 1.9198 - val_acc: 0.5310\nEpoch 100/100\n25/25 [==============================] - 16s 641ms/step - loss: 1.0828 - acc: 0.7040 - val_loss: 1.9060 - val_acc: 0.5380\n" ] ], [ [ "# Evaluation", "_____no_output_____" ] ], [ [ "# 학습시켰던 데이터\nmodel.evaluate(pad_x_train, y_train)", "281/281 [==============================] - 16s 56ms/step - loss: 1.3192 - acc: 0.6544\n" ] ], [ [ "x_test 데이터 전처리", "_____no_output_____" ] ], [ [ "pad_x_test = tf.keras.preprocessing.sequence.pad_sequences(x_test, maxlen=500)", "_____no_output_____" ], [ "def pad_make(x_data):\n pad_x = tf.keras.preprocessing.sequence.pad_sequences(x_data, maxlen=500)\n return pad_x", "_____no_output_____" ], [ "pad_make_x = pad_make(x_test)", "_____no_output_____" ], [ "model.evaluate(pad_make_x, y_test)", "71/71 [==============================] - 4s 56ms/step - loss: 1.9766 - acc: 0.5419\n" ], [ "model.evaluate(pad_x_test, y_test)", "71/71 [==============================] - 4s 57ms/step - loss: 1.9766 - acc: 0.5419\n" ] ], [ [ "train과 test의 acc 유사하기 때문에 학습이 잘 됨을 볼 수 있음", "_____no_output_____" ] ], [ [ "import matplotlib.pyplot as plt", "_____no_output_____" ], [ "plt.plot(hist.history['loss'])\nplt.plot(hist.history['val_loss'])\nplt.show()", "_____no_output_____" ], [ "plt.plot(hist.history['acc'])\nplt.plot(hist.history['val_acc'])\nplt.show()", "_____no_output_____" ], [ "from sklearn.metrics import classification_report", "_____no_output_____" ], [ "y_train_pred = model.predict(pad_x_train)\ny_train_pred[0]", "_____no_output_____" ], [ "y_pred = np.argmax(y_train_pred, axis=1)\ny_pred.shape", "_____no_output_____" ], [ "len(y_train)", "_____no_output_____" ], [ "print(classification_report(y_train, y_pred))", " precision recall f1-score support\n\n 0 0.00 0.00 0.00 55\n 1 0.30 0.80 0.44 432\n 2 0.00 0.00 0.00 74\n 3 0.95 0.95 0.95 3159\n 4 0.88 0.89 0.89 1949\n 5 0.00 0.00 0.00 17\n 6 0.00 0.00 0.00 48\n 7 0.00 0.00 0.00 16\n 8 0.00 0.00 0.00 139\n 9 0.00 0.00 0.00 101\n 10 0.09 0.61 0.15 124\n 11 0.00 0.00 0.00 390\n 12 0.00 0.00 0.00 49\n 13 0.00 0.00 0.00 172\n 14 0.00 0.00 0.00 26\n 15 0.00 0.00 0.00 20\n 16 0.42 0.66 0.51 444\n 17 0.00 0.00 0.00 39\n 18 0.00 0.00 0.00 66\n 19 0.38 0.76 0.51 549\n 20 0.14 0.00 0.01 269\n 21 0.00 0.00 0.00 100\n 22 0.00 0.00 0.00 15\n 23 0.00 0.00 0.00 41\n 24 0.00 0.00 0.00 62\n 25 0.00 0.00 0.00 92\n 26 0.00 0.00 0.00 24\n 27 0.00 0.00 0.00 15\n 28 0.00 0.00 0.00 48\n 29 0.00 0.00 0.00 19\n 30 0.00 0.00 0.00 45\n 31 0.00 0.00 0.00 39\n 32 0.00 0.00 0.00 32\n 33 0.00 0.00 0.00 11\n 34 0.00 0.00 0.00 50\n 35 0.00 0.00 0.00 10\n 36 0.00 0.00 0.00 49\n 37 0.00 0.00 0.00 19\n 38 0.00 0.00 0.00 19\n 39 0.00 0.00 0.00 24\n 40 0.00 0.00 0.00 36\n 41 0.00 0.00 0.00 30\n 42 0.00 0.00 0.00 13\n 43 0.00 0.00 0.00 21\n 44 0.00 0.00 0.00 12\n 45 0.00 0.00 0.00 18\n\n accuracy 0.65 8982\n macro avg 0.07 0.10 0.08 8982\nweighted avg 0.59 0.65 0.61 8982\n\n" ], [ "y_test_pred = model.predict(pad_x_test)", "_____no_output_____" ], [ "y_pred = np.argmax(y_test_pred, axis=1)", "_____no_output_____" ], [ "print(classification_report(y_test, y_pred))", " precision recall f1-score support\n\n 0 0.00 0.00 0.00 12\n 1 0.17 0.53 0.26 105\n 2 0.00 0.00 0.00 20\n 3 0.93 0.89 0.91 813\n 4 0.70 0.72 0.71 474\n 5 0.00 0.00 0.00 5\n 6 0.00 0.00 0.00 14\n 7 0.00 0.00 0.00 3\n 8 0.00 0.00 0.00 38\n 9 0.00 0.00 0.00 25\n 10 0.07 0.37 0.11 30\n 11 0.00 0.00 0.00 83\n 12 0.00 0.00 0.00 13\n 13 0.00 0.00 0.00 37\n 14 0.00 0.00 0.00 2\n 15 0.00 0.00 0.00 9\n 16 0.11 0.22 0.15 99\n 17 0.00 0.00 0.00 12\n 18 0.00 0.00 0.00 20\n 19 0.23 0.47 0.31 133\n 20 0.33 0.04 0.08 70\n 21 0.00 0.00 0.00 27\n 22 0.00 0.00 0.00 7\n 23 0.00 0.00 0.00 12\n 24 0.00 0.00 0.00 19\n 25 0.00 0.00 0.00 31\n 26 0.00 0.00 0.00 8\n 27 0.00 0.00 0.00 4\n 28 0.00 0.00 0.00 10\n 29 0.00 0.00 0.00 4\n 30 0.00 0.00 0.00 12\n 31 0.00 0.00 0.00 13\n 32 0.00 0.00 0.00 10\n 33 0.00 0.00 0.00 5\n 34 0.00 0.00 0.00 7\n 35 0.00 0.00 0.00 6\n 36 0.00 0.00 0.00 11\n 37 0.00 0.00 0.00 2\n 38 0.00 0.00 0.00 3\n 39 0.00 0.00 0.00 5\n 40 0.00 0.00 0.00 10\n 41 0.00 0.00 0.00 8\n 42 0.00 0.00 0.00 3\n 43 0.00 0.00 0.00 6\n 44 0.00 0.00 0.00 5\n 45 0.00 0.00 0.00 1\n\n accuracy 0.54 2246\n macro avg 0.06 0.07 0.05 2246\nweighted avg 0.52 0.54 0.52 2246\n\n" ] ], [ [ "비슷한 부분끼리 0임을 확인 -> words=10000 제한 때문에 0이 발생", "_____no_output_____" ] ], [ [ "", "_____no_output_____" ] ] ]

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

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

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/bxck75/Python_Helpers/blob/master/latestv1.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ] ], [ [ "''' install 3dparty sheit '''\nfrom IPython.display import clear_output as cle\nfrom pprint import pprint as print\nfrom PIL import Image\nimport os\nimport sys\nimport json\nimport IPython\n\n''' default sample data delete '''\nos.system('rm -r sample_data')\n\n''' set root paths '''\nroot = '/content'\ngdrive_root = '/content/drive/My Drive'\nhelpers_root = root + '/installed_repos/Python_Helpers'\n\n''' setup install the Helpers module '''\nos.system('git clone https://github.com/bxck75/Python_Helpers.git ' + helpers_root) \nos.system('python ' + helpers_root + 'setup.py install')\n\n''' import helpers '''\nos.chdir(helpers_root)\nimport main as main_core\nMainCore = main_core.main()\nHelpCore = MainCore.Helpers_Core\nFScrape = HelpCore.flickr_scrape\nfromGdrive = HelpCore.GdriveD\ntoGdrive = HelpCore.ZipUp.ZipUp\n\ncle()", "_____no_output_____" ], [ "dir(HelpCore)\nFScrape(['Ork','Troll','Dragon'], 25, '/content/images')\nimgs_path_list = HelpCore.GlobX(img_dir,'*.*g')\nprint(imgs_path_list)", "_____no_output_____" ], [ "dir(HelpCore)", "_____no_output_____" ], [ "print(MainCore.Helpers_Core.cloner('/content/images'))", "_____no_output_____" ], [ "# def LandMarks(img_dir,out_dir):\n# ''' Folder glob and Landmark all found imgs '''\n# imgs_path_list = HelpCore.GlobX(img_dir,'*.*g')\n# imgs_path_list.sort()\n \n# i=0\n# for i in range(len(imgs_path_list)):\n# ''' make folders '''\n\n# img_pathAr = imgs_path_list[i]\n# # img_pathAr.Split(Path.DirectorySeparatorChar) # returns array of the path\n# # img_pathAr.Lenth - 2\n# # print(img_pathAr[2])\n \n# os.system('mkdir -p '+os.path.join(out_dir,'/org'))\n# os.system('mkdir -p '+os.path.join(out_dir,'/marked'))\n# ''' backup original '''\n# os.system('cp imgs_path_list[i] '+out_dir + '/org')\n# ''' loop over images '''\n# img = cv.imread(imgs_path_list[i])\n# for c, w, h in img.shape:\n# print(3, w, h)\n# if img is None:\n# print('Failed to load image file:', fname)\n# sys.exit(1)\n# fork_img = img\n# ''' Mark the image '''\n# gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)\n# lsd = cv.line_descriptor_LSDDetector.createLSDDetector()\n# lines = lsd.detect(gray, 1, 1)\n# for kl in lines:\n# if kl.octave == 0:\n# pt1 = (int(kl.startPointX), int(kl.startPointY))\n# pt2 = (int(kl.endPointX), int(kl.endPointY))\n# cv.line(fork_img, pt1, pt2, [255, 0, 0], 2)\n\n\n# cv.waitKey(0)\n# cv.destroyAllWindows()\n# cv.imwrite('nice.jpg',img)\n# # marked\n# cv.imwrite('nice.jpg',img)\n# i += 1", "_____no_output_____" ], [ "# def org_n_marked_clone(img_path,id=0):\n# ''' backup the originals '''\n# drive, path_and_file = os.path.splitdrive(img_path)\n# path, file = os.path.split(path_and_file)\n# fi, ex = file.split(.)\n# fi.rstrip(string.digits)\n\n# ''' compose the new paths '''\n# org_path = path + '/org/' + fi + '_%d' % id\n# marked_path = path + '/marked/' + fi + '_%d' % id\n# ''' return the list '''\n# return [org_path,marked_path]\n\n\n# org_n_marked_clone('/content/images/img_1.jpg')", "_____no_output_____" ], [ "os.path.join( path+'/org', file )", "_____no_output_____" ], [ "import sys\nimport cv2 as cv\n\nif __name__ == '__main__':\n print(__doc__)\n\n fname = '/content/images/img_1.jpg'\n\n img = cv.imread(fname)\n\n if img is None:\n print('Failed to load image file:', fname)\n sys.exit(1)\n\n gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)\n\n lsd = cv.line_descriptor_LSDDetector.createLSDDetector()\n\n lines = lsd.detect(gray, 1, 1)\n for kl in lines:\n if kl.octave == 0:\n # cv.line only accepts integer coordinate\n pt1 = (int(kl.startPointX), int(kl.startPointY))\n pt2 = (int(kl.endPointX), int(kl.endPointY))\n cv.line(img, pt1, pt2, [255, 0, 0], 2)\n\n # plt.imshow('output', img)\n cv.waitKey(0)\n cv.destroyAllWindows()\n cv.imwrite('nice.jpg',img)", "_____no_output_____" ], [ "from google.colab import drive\ndrive.mount('/content/drive')", "_____no_output_____" ], [ "help(HelpCore)", "_____no_output_____" ], [ "help(FScrape)\n# search_list,img_dir,qty = ['zombie'], 'images', 21\n# FScrape(search_list,qty,img_dir)\nfuncs=[\n 'BigHelp',\n 'Colab_root',\n 'ColorPrint',\n 'FileView',\n 'FlickrS',\n 'GdriveD',\n 'Gdrive_root',\n 'GlobX',\n 'GooScrape',\n 'ImgCrawler',\n 'ImgTools',\n 'LogGER',\n 'Logger',\n 'MethHelp',\n 'Ops',\n 'Repo_List',\n 'Resize',\n 'Sys_Cmd',\n 'Sys_Exec',\n 'ZipUp',\n ]\n\ndef img_show_folder(folder):\n # fname = '/content/images/img_1.jpg'\n folder_path = Path(folder)\n GlobX(folder_path,'*.*g')\n for base, dirs, files in os.walk('/content/images'):\n files.sort()\n for i in range(len(files)):\n print(base+'/'+files[i])\n img = cv.imread(base+'/'+files[i])\n plt.imshow(img,cmap=dark2)\n plt.show()\n\nHelpCore.GlobX('/content/images','*.*g')\n# search_list, img_dir, qty = ['zombie'], 'images', 200\n\n# FScrape(search_list, qty, img_dir)", "_____no_output_____" ], [ "# toGdrive('cv2_samples','/content/drive/My Drive','/content/installed_repos/opencv/samples')\n# Load zipper\n# Zipper = toGdrive.GdriveD\n# Zip folder\n# images_set_name, gdrive_folder, folder_to_zip = 'cv2_samples', '/content/drive/My Drive', '/content/installed_repos/opencv/samples'\n# result=Zipper(images_set_name,gdrive_folder,folder_to_zip).ZipUp\n# Print Resulting hash\nprint(result)\ndir(toGdrive)\n# HelpCore.GlobX('/content', '*.py')", "_____no_output_____" ], [ "!python /content/installed_repos/opencv/samples/dnn/segmentation.py --zoo --input --framework 'tensorflow'", "_____no_output_____" ], [ "%cd /content/installed_repos/opencv/samples/dnn\n!cat segmentation.py", "_____no_output_____" ] ], [ [ "parser = argparse.ArgumentParser(add_help=False)\nparser.add_argument('--zoo', default=os.path.join(os.path.dirname(os.path.abspath(__file__)), 'models.yml'),\n help='An optional path to file with preprocessing parameters.')\nparser.add_argument('--input', help='Path to input image or video file. Skip this argument to capture frames from a camera.')\nparser.add_argument('--framework', choices=['caffe', 'tensorflow', 'torch', 'darknet'],\n help='Optional name of an origin framework of the model. '\n 'Detect it automatically if it does not set.')\nparser.add_argument('--colors', help='Optional path to a text file with colors for an every class. '\n 'An every color is represented with three values from 0 to 255 in BGR channels order.')\nparser.add_argument('--backend', choices=backends, default=cv.dnn.DNN_BACKEND_DEFAULT, type=int,\n help=\"Choose one of computation backends: \"\n \"%d: automatically (by default), \"\n \"%d: Halide language (http://halide-lang.org/), \"\n \"%d: Intel's Deep Learning Inference Engine (https://software.intel.com/openvino-toolkit), \"\n \"%d: OpenCV implementation\" % backends)\nparser.add_argument('--target', choices=targets, default=cv.dnn.DNN_TARGET_CPU, type=int,\n help='Choose one of target computation devices: '\n '%d: CPU target (by default), '\n '%d: OpenCL, '\n '%d: OpenCL fp16 (half-float precision), '\n '%d: VPU' % targets)\nargs, _ = parser.parse_known_args()\n", "_____no_output_____" ] ], [ [ "# !wget https://drive.google.com/open?id=1KNfN-ktxbPJMtmdiL-I1WW0IO1B_2EG2\n# landmarks_file=['1KNfN-ktxbPJMtmdiL-I1WW0IO1B_2EG2','/content/shape_predictor_68_face_landmarks.dat']\n# fromGdrive.GdriveD(landmarks_file[0],landmarks_file[1])\nimport cv2\nimport numpy\nimport dlib\nimport matplotlib.pyplot as plt\n\n# cap = cv2.VideoCapture(0)\n\ndetector = dlib.get_frontal_face_detector()\npredictor = dlib.shape_predictor(\"/content/shape_predictor_68_face_landmarks.dat\")\n\nwhile True:\n _, frame = cap.read()\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n\n faces = detector(gray)\n for face in faces:\n x1 = face.left()\n y1 = face.top()\n x2 = face.right()\n y2 = face.bottom()\n #cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0), 3)\n\n landmarks = predictor(gray, face)\n\n for n in range(0, 68):\n x = landmarks.part(n).x\n y = landmarks.part(n).y\n cv2.circle(frame, (x, y), 4, (255, 0, 0), -1)\n\n\n plt.imshow(\"Frame\", frame)\n\n key = cv2.waitKey(1)\n if key == 27:\n break\ncap.release()\ncv2.destroyAllWindows()\n", "_____no_output_____" ], [ "''' install 3dparty sheit '''\nfrom IPython.display import clear_output as cle\nfrom pprint import pprint as print\nfrom PIL import Image\nimport os\nimport sys\nimport json\nimport IPython\n\n''' default sample data delete '''\nos.system('rm -r sample_data')\n\n''' set root paths '''\nroot = '/content'\ngdrive_root = '/content/drive/My Drive'\nhelpers_root = root + '/installed_repos/Python_Helpers'\n\n''' setup install the Helpers module '''\nos.system('git clone https://github.com/bxck75/Python_Helpers.git ' + helpers_root) \nos.system('python ' + helpers_root + 'setup.py install')\n", "_____no_output_____" ], [ "os.chdir(helpers_root)\nfrom main import main\nlandmarks_68_file = '1KNfN-ktxbPJMtmdiL-I1WW0IO1B_2EG2'\nlandmarks_194_file = '1fMOT_0f5clPbZXsphZyrGcLXkIhSDl3o'", "_____no_output_____" ], [ "os.chdir(root)\n\nimages_set_name, gdrive_folder, folder_to_zip = 'cv2_samples', '/content/installed_repos/opencv/samples/dnn/*', '/content/drive/My Drive'\nresults=HelpCore.ZipUp.ZipUp(images_set_name,gdrive_folder,folder_to_zip).ZipUp\nprint(results)", "_____no_output_____" ], [ "!zip -r cv2_examples.zip /content/installed_repos/opencv/samples/dnn /content/installed_repos/opencv/samples/python", "_____no_output_____" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "Dieser Block erzeugt eine Darstellung, die die ganze Breite des Fensters ausnutzt.", "_____no_output_____" ] ], [ [ "%%HTML\n<style>.container{width:100%;}</style>", "_____no_output_____" ] ], [ [ "Dieser Block schaltet die Überprüfung auf Schönheitsfehler ein. Wir ignorieren die Konvention, dass zwischen Definitionen zwei Leerzeilen stehen sollen, um die Lesbarkeit zu erhöhen. Wir erlauben auch mehrere Leerzeichen vor einem Operator, um sequenzielle Zuweisungen am `=` ausrichten zu können.", "_____no_output_____" ] ], [ [ "%load_ext pycodestyle_magic\n%flake8_on --ignore E302,E305,E221", "_____no_output_____" ] ], [ [ "Wir benötigen außerdem *Graphviz* zur Visualisierung.", "_____no_output_____" ] ], [ [ "import graphviz", "_____no_output_____" ] ], [ [ "# Splay Trees\n\nIn diesem Notebook wird eine bestimmte Art von selbstbalancierenden Bäumen gezeigt, die *Splay Trees*. Diese Datenstruktur wurde [1985 von Sleator und Tarjan eingeführt](http://www.cs.cmu.edu/~sleator/papers/self-adjusting.pdf \"D. D. Sleator, R. E. Tarjan (1985): Self-Adjusting Binary Search Trees. Journal of the ACM, 32(3) 652-686\"). Im Gegensatz zu anderen selbstbalancierenden Bäumen wie AVL-Bäumen wird bei Splay Trees nicht gefordert, dass der Baum zu allen Zeiten so gut wie möglich balanciert ist. Stattdessen wird der Baum dahingehend optimiert, dass häufig verwendete Elemente nahe an der Wurzel sind.\n\nAuf Basis dieser Bäume soll später eine alternative Implementierung von Mengen in der Programmiersprache Python entstehen. In der Referenzimplementierung *CPython* sind [Mengen auf Basis von *Hashtabellen* implementiert](https://github.com/python/cpython/blob/3.7/Objects/setobject.c \"R. D. Hettinger et al. (2019): cpython/Objects/setobject.c, GitHub\"). Viele andere weit verbreitete Implementierungen anderer Programmiersprachen benutzen für Mengen ebenfalls Hashtabellen oder haben dies zumindest als Option, wie in [Java](https://docs.oracle.com/en/java/javase/13/docs/api/java.base/java/util/Set.html \"Oracle Corporation (2019): Set (Java SE 13 & JDK 13)\"), [.NET (C#)](https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.iset-1?view=netframework-4.8, \"Microsoft Corporation (2020): ISet<T> Interface (System.Collections.Generic), Microsoft Docs\"), [JavaScript](https://v8.dev/blog/hash-code \"S. Gunasekaran (2018): Optimizing hash tables: hiding the hash code, V8 Blog\") oder [PHP](https://www.php.net/manual/en/class.ds-set.php \"The PHP Group (2020): PHP: Set, Manual\"). Jedoch sind mit der Verwendung von Bäumen für Mengen einige mengenlastige Programmierprobleme einfacher zu lösen, da diese Mengen *geordnet* sind und somit beispielsweise ein einfach zu bestimmendes Minimum und ein Maximum haben.\n\nGeordnete binäre Bäume eignen sich, um Mengen zu implementieren, da insbesondere in beiden keine doppelten Elemente vorkommen. Wir müssen für geordnete Mengen außerdem fordern, dass alle Elemente geordnet werden können. Wir behandeln später, wie wir beliebigen Nutzlasten in Python eine Ordnung geben können.\n\nDie reine Datenstruktur – ohne Operationen – ist bei Splay Trees genauso wie bei regulären geordneten binären Bäumen definiert: $\\mathrm{Node}(p, l, r)$ ist ein Baum, wobei\n- $p$ eine Nutzlast (payload) ist,\n- $l$ der linke Teilbaum ist und\n- $r$ der rechte Teilbaum ist.", "_____no_output_____" ] ], [ [ "class Node:\n def __init__(self, payload, left, right):\n self.payload = payload\n self.left = left\n self.right = right", "_____no_output_____" ] ], [ [ "Wir verlangen dabei:\n\n- Für alle Nutzlasten aus dem linken Teilbaum $l$ gilt, dass sie kleiner als die Nutzlast $p$ sind.\n- Für alle Nutzlasten aus dem rechten Teilbaum $r$ gilt, dass sie größer als die Nutzlast $p$ sind.\n\nDiese Aussagen können auch als $l < p < r$ formuliert werden.\n\n## Visualisierung\n\nWir wollen, um die Splay Trees besser erklären zu können, zuerst ihre Visualisierung implementieren. Bäume, die eine Untermenge der Graphen sind, können wir mit dem [Python-Interface](https://github.com/xflr6/graphviz \"S. Bank (2019): graphviz, GitHub\") zu [*Graphviz*](https://graphviz.org/ \"J. Ellson et al. (2019): Graphviz\") visualisieren.\n\nWir definieren dazu zuerst die interne Methode `_graph` der Klasse `Node`, die einem bestehenden Graphen `dot` die eigene Struktur hinzufügt. Wir müssen uns dabei merken, welche Namen wir schon für Knoten im Graph benutzt haben, wofür `_graph` noch die Menge `used` übergeben bekommt. Als Namen benutzen wir immer die `id` des Knotens, außer, wenn wir leere Knoten markieren, für die wir kein `Node`-Objekt halten. In diesem Fall benutzen wir einen Zähler `key`, den `_graph` ebenfalls übergeben bekommt. Den geänderten Zähler gibt `_graph` zurück, `used` brauchen wir nicht zurückgeben, da Mengen per Referenz weitergegeben werden.", "_____no_output_____" ] ], [ [ "def _graph(self, dot, used, key):\n used.add(id(self))\n dot.node(str(id(self)), label=str(self.payload))\n if not (self.left is None and self.right is None):\n for node in self.left, self.right:\n if node is not None:\n dot.edge(str(id(self)), str(id(node)))\n key = node._graph(dot, used, key)\n else:\n while True:\n key += 1\n if key not in used:\n break\n used.add(key)\n dot.node(str(key), shape=\"point\")\n dot.edge(str(id(self)), str(key))\n return key\n\nNode._graph = _graph\ndel _graph", "_____no_output_____" ] ], [ [ "Die nach außen offenstehende Methode `graph` (ohne Unterstrich) der Klasse `Node` leistet nur die Vorarbeit für `_graph` und ruft diese Methode dann auf. `graph` unterstützt allerdings beliebig viele `additionals`, also `Node`s, die in dieser Reihenfolge ebenfalls in den Graphen eingefügt werden. So können wir mehrere Bäume in einem Schaubild sehen und insbesondere Schritte besser nachvollziehen.", "_____no_output_____" ] ], [ [ "def graph(self, *additionals):\n dot = graphviz.Digraph()\n used = set()\n key = self._graph(dot, used, 0)\n for el in additionals:\n key = el._graph(dot, used, key)\n return dot\n\nNode.graph = graph\ndel graph", "_____no_output_____" ] ], [ [ "Um bei solchen Schritten anmerken zu können, was geschieht, definieren wir die Klasse `Method`, die sich auch mit `_graph` visualisieren lassen kann. Solche Knoten werden dann als Rechtecke angezeigt.", "_____no_output_____" ] ], [ [ "class Method:\n def __init__(self, name):\n self.name = name\n\n def _graph(self, dot, used, key):\n used.add(id(self))\n dot.node(str(id(self)), label=str(self.name) + \" ⇒\",\n shape=\"rectangle\", style=\"dotted\")\n return key", "_____no_output_____" ] ], [ [ "Zuletzt definieren wir `TempTree`, dessen Verbindung zu seinem einzigen (links oder rechts sitzenden) Kind an der Seite statt unten sitzt und gestrichelt gezeichnet wird. Der Baum selbst wird als Dreieck gezeichnet. Wir werden damit später Bäume visualisieren, bei denen wir nur die äußersten Knoten zeichnen und dazwischen Knoten in der Darstellung auslassen.", "_____no_output_____" ] ], [ [ "class TempTree:\n def __init__(self, name, child, left):\n self.name = name\n self.child = child\n self.left = left\n\n def _graph(self, dot, used, key):\n used.add(id(self))\n dot.node(str(id(self)), label=str(self.name), shape=\"triangle\")\n if self.child is not None:\n dot.edge(str(id(self)), str(id(self.child)), style=\"dashed\",\n tailport=\"w\" if self.left else \"e\")\n key = self.child._graph(dot, used, key)\n else:\n while True:\n key += 1\n if key not in used:\n break\n used.add(key)\n dot.node(str(key), shape=\"point\")\n dot.edge(str(id(self)), str(key), style=\"dashed\",\n tailport=\"w\" if self.left else \"e\")\n return key\n\nTempTree.graph = Node.graph", "_____no_output_____" ] ], [ [ "## Splaying\n\nDie Besonderheit von Splay Trees ist, dass mit allen Baumoperationen, die ein Element im Baum lokalisieren, eine besondere Operation, der *Splay*, durchgeführt wird. Mit Baumoperationen, die ein Element im Baum lokalisieren, sind alle Operationen auf den Baum gemeint, die den Baum auf der Suche nach einem Element oder auf der Suche nach dem richtigen Ort für ein Element durchsuchen. Dazu gehören das Einfügen, Löschen und Finden von Elementen.\n\nDer Splay ist eine Funktion, die einen Baum dahingehend modifiziert, dass eine Nutzlast, die schon im Baum enthalten ist, die neue Wurzel des Baums wird.\n\n$$\\mathrm{Node}.\\mathrm{splay}: \\mathrm{Payload} \\to \\mathrm{Node}$$\n\nIst die angegebene Nutzlast im Baum, so ist gerade der Knoten, der sie enthält, die neue Wurzel.\n\nWir arbeiten mit dem *Top-Down*-Ansatz, bei dem wir von der Wurzel aus so lange Knoten beiseite legen, bis der zu splayende Knoten die Wurzel darstellt, und diese beiseite gelegten Knoten wieder unterordnen. Dieser Ansatz wurde in der ursprünglichen Veröffentlichung von Sleator und Tarjan bereits beschrieben (S. 667ff.), aber erst [1987 von Mäkinen als in Komplexität etwas begrenzter analysiert](https://link.springer.com/article/10.1007%2FBF01933728 \"E. Mäkinen (1987): On top-down splaying. BIT Numerical Mathematics, 27 330-339 (SpringerLink)\").\n\nBeim Top-Down-Splaying werden zusätzlich zum Baum, der bearbeitet wird, die zwei Bäume $L, R$ betrachtet. Wenn Knoten beiseite gelegt werden, so werden sie in $L$ und $R$ abgelegt. In $L$ kommen die Elemente, die kleiner als der zu splayende Knoten sind, in $R$ die, die größer sind. Dabei bleiben der rechteste Knoten von $L$ und der linkeste Knoten von $R$ immer frei, sodass dort leicht angefügt werden kann. Wir definieren dafür zunächst $\\mathrm{insert\\_left}$ und $\\mathrm{insert\\_right}$, die keine neuen Nutzlasten, sondern existierende Knoten ganz links (für $R$) bzw. rechts (für $L$) außen an den Baum anfügen. Dabei ist der Baum selbst der erste Parameter, der neue Knoten der zweite. Die formale Definition ist rekursiv.\n\n$$\\mathrm{insert\\_left}: \\mathrm{Node} \\times \\mathrm{Node} \\to \\mathrm{Node}$$\n$$\\begin{aligned}\n\\mathrm{Nil}.\\mathrm{insert\\_left}(\\mathrm{Node}(a, b, c)) &= \\mathrm{Node}(a, b, c) \\\\\n\\mathrm{Node}(x, y, z).\\mathrm{insert\\_left}(\\mathrm{Nil}) &= \\mathrm{Node}(x, y, z) \\\\\n\\mathrm{Node}(x, y, z).\\mathrm{insert\\_left}(\\mathrm{Node}(a, b, c)) &= \\mathrm{Node}(x, y.\\mathrm{insert\\_left}(\\mathrm{Node}(a, b, c)), z)\n\\end{aligned}$$\n\n$$\\mathrm{insert\\_right}: \\mathrm{Node} \\times \\mathrm{Node} \\to \\mathrm{Node}$$\n$$\\begin{aligned}\n\\mathrm{Nil}.\\mathrm{insert\\_right}(\\mathrm{Node}(a, b, c)) &= \\mathrm{Node}(a, b, c) \\\\\n\\mathrm{Node}(x, y, z).\\mathrm{insert\\_right}(\\mathrm{Nil}) &= \\mathrm{Node}(x, y, z) \\\\\n\\mathrm{Node}(x, y, z).\\mathrm{insert\\_right}(\\mathrm{Node}(a, b, c)) &= \\mathrm{Node}(x, y, z.\\mathrm{insert\\_right}(\\mathrm{Node}(a, b, c)))\n\\end{aligned}$$\n\nUm das Splayen im Kontext dieser temporären Bäume definieren zu können, definieren wir die Funktion $\\mathrm{splay\\_step}$, die einen Splay-Schritt für eine Nutzlast durchführt, und dabei auf einem Tripel aus $L$, dem Baum selbst, und $R$ operiert, und dieses Tripel i. A. modifiziert zurückgibt.\n\n$$\\langle\\mathrm{Node}, \\mathrm{Node}, \\mathrm{Node}\\rangle.\\mathrm{splay\\_step}: \\mathrm{Payload} \\to \\langle\\mathrm{Node}, \\mathrm{Node}, \\mathrm{Node}\\rangle$$\n\nDie $\\mathrm{splay}$-Funktion muss nur leere Bäume $L, R$ konstruieren und den ersten $\\mathrm{splay\\_step}$ starten. Die übrigen Schritte werden von dort aus rekursiv aufgerufen. Sind alle $\\mathrm{splay\\_step}$s getan, gibt sie den mittleren Baum zurück.\n\n$$\\langle\\mathrm{Nil}, \\mathrm{Node}(x, y, z), \\mathrm{Nil}\\rangle.\\mathrm{splay\\_step}(k) = \\langle\\mathrm{Nil}, \\mathrm{Node}(a, b, c), \\mathrm{Nil}\\rangle \\Rightarrow \\mathrm{Node}(x, y, z).\\mathrm{splay}(k) = \\mathrm{Node}(a, b, c)$$\n\nIn jedem Schritt werden zwei Knoten beiseite gelegt. Sollte der Knoten mit der gesuchten Nutzlast auf der zweitobersten Ebene sein, so wird natürlich nur noch ein Knoten beiseite gelegt. Diesen Schritt behandeln wir zuerst. Ist der Knoten dabei das linke Kind seines Elternknotens, so bezeichnen wir diesen Schritt als *Zig*.\n\n### Zig und Zag\n\nDie folgende Grafik illustriert den Schritt. Die Dreiecke $L, R$ stehen hier für ganze Bäume, und die ausgehenden Pfeile stehen für die rechteste bzw. linkeste Stelle in diesen Bäumen.", "_____no_output_____" ] ], [ [ "# flake8: noqa\n# blocks solely for drawing are exempt because I consider\n# semicolons and longer lines more beneficial to the reading flow there\nx1 = Node(\"x\", None, None); y1 = Node(\"y\", None, None); z1 = Node(\"z\", None, None)\na1 = Node(\"a\", x1, y1); b1 = Node(\"b\", a1, z1)\nl1 = TempTree(\"L\", None, False); r1 = TempTree(\"R\", None, True)\n\nx2 = Node(\"x\", None, None); y2 = Node(\"y\", None, None); z2 = Node(\"z\", None, None)\na2 = Node(\"a\", x2, y2); b2 = Node(\"b\", None, z2)\nl2 = TempTree(\"L\", None, False); r2 = TempTree(\"R\", b2, True)\n\ndot = l1.graph(b1, r1, Method(\"zig()\"), l2, a2, r2)\nfor subtree in x1, y1, z1, x2, y2, z2:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Wir bewegen den Knoten $a$ an die Wurzel, wobei $b$ gemeinsam mit seinem rechten Teilbaum $z$ links unten an $R$ angefügt wird. Die Ordnung bleibt erhalten, da $b > a$ ist, und da alle Elemente, die zuvor schon in $R$ waren, auch größer als $b$ sind.\n\nFormal definieren wir\n\n$$\\langle L, \\mathrm{Node}(b, \\mathrm{Node}(a, x, y), z), R\\rangle.\\mathrm{splay\\_step}(a) = \\langle L, \\mathrm{Node}(a, x, y), R.\\mathrm{insert\\_left}(\\mathrm{Node}(b, \\mathrm{Nil}, z)\\rangle.\\mathrm{splay\\_step}(a)$$\n\nZu beachten ist, dass wir dabei auf das Ergebnis wieder einen Splayschritt durchführen. Wir haben zwar jetzt schon die gesuchte Nutzlast an der Wurzel, wollen aber das, was nach dem letzten regulären Schritt zu tun ist, nur einmal definieren. Hinzu kommt, dass dies für die anderen Optionen, Splay-Schritte durchzuführen, im Allgemeinen nicht der Fall ist, dann wird der Knoten noch nicht an der Wurzel sein. In der Implementierung wird später immerzu überprüft werden, ob noch ein Schritt benötigt wird, und dann der richtige Schritt ausgeführt.\n\nDie Implementierung in Python handhaben wir ein wenig anders. Die als intern markierte Methode `_zig` bekommt Zeiger auf die momentanen Extrema in $L$ und $R$, schreibt das Objekt selbst in $R$ fest, und überschreibt die Referenz auf sich selbst dann mit dem linken Knoten unter sich. So vermeiden wir das teure Konstruieren neuer Objekte. Die neuen Extrema sowie der neue Zeiger auf den betrachteten Knoten werden zurückgegeben (erst $L$, dann der Hauptbaum, dann $R$).", "_____no_output_____" ] ], [ [ "def _zig(self, max_less, min_greater):\n # self = Node(b, Node(a, x, y), z)\n min_greater.left = self\n new_min_greater = self\n # new_min_greater = Node(b, Node(a, x, y), z)\n new_self = self.left\n # new_self = Node(a, x, y)\n new_min_greater.left = None\n # new_min_greater = Node(b, Nil, z)\n return max_less, new_self, new_min_greater\n\nNode._zig = _zig\ndel _zig", "_____no_output_____" ] ], [ [ "Bei *Zag* ist der zu splayende Knoten das rechte Kind der Wurzel:", "_____no_output_____" ] ], [ [ "# flake8: noqa\nx1 = Node(\"x\", None, None); y1 = Node(\"y\", None, None); z1 = Node(\"z\", None, None)\na1 = Node(\"a\", y1, z1); b1 = Node(\"b\", x1, a1)\nl1 = TempTree(\"L\", None, False); r1 = TempTree(\"R\", None, True)\n\nx2 = Node(\"x\", None, None); y2 = Node(\"y\", None, None); z2 = Node(\"z\", None, None)\na2 = Node(\"a\", y2, z2); b2 = Node(\"b\", x2, None)\nl2 = TempTree(\"L\", b2, False); r2 = TempTree(\"R\", None, True)\n\ndot = l1.graph(b1, r1, Method(\"zag()\"), l2, a2, r2)\nfor subtree in x1, y1, z1, x2, y2, z2:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Formale Definition und Implementierung sind ähnlich.\n\n$$\\langle L, \\mathrm{Node}(b, x, \\mathrm{Node}(a, y, z)), R\\rangle.\\mathrm{splay\\_step}(a) = \\langle L.\\mathrm{insert\\_right}(\\mathrm{Node}(b, x, \\mathrm{Nil})), \\mathrm{Node}(a, y, z), R\\rangle.\\mathrm{splay\\_step}(a)$$", "_____no_output_____" ] ], [ [ "def _zag(self, max_less, min_greater):\n # self = Node(b, x, Node(a, y, z))\n max_less.right = self\n new_max_less = self\n # new_min_greater = Node(b, x, Node(a, y, z))\n new_self = self.right\n # new_self = Node(a, y, z)\n new_max_less.right = None\n # new_min_greater = Node(b, x, Nil)\n return new_max_less, new_self, min_greater\n\nNode._zag = _zag\ndel _zag", "_____no_output_____" ] ], [ [ "### Zig-Zig und Zag-Zag\n\nAls nächstes behandeln wir den Fall, dass der Knoten wenigstens zwei Ebenen von der Wurzel entfernt ist, und sowohl der Knoten als auch sein Elternknoten ein linkes Kind sind. Die Operation, die auf diese Ausgangssituation anzuwenden ist, bezeichnen wir als *Zig-Zig*. Diese Operation sieht so aus:", "_____no_output_____" ] ], [ [ "# flake8: noqa\nw1 = Node(\"w\", None, None); x1 = Node(\"x\", None, None); y1 = Node(\"y\", None, None); z1 = Node(\"z\", None, None)\na1 = Node(\"a\", w1, x1); b1 = Node(\"b\", a1, y1); c1 = Node(\"c\", b1, z1)\nl1 = TempTree(\"L\", None, False); r1 = TempTree(\"R\", None, True)\n\nw2 = Node(\"w\", None, None); x2 = Node(\"x\", None, None); y2 = Node(\"y\", None, None); z2 = Node(\"z\", None, None)\na2 = Node(\"a\", w2, x2); c2 = Node(\"c\", y2, z2); b2 = Node(\"b\", None, c2)\nl2 = TempTree(\"L\", None, False); r2 = TempTree(\"R\", b2, True)\n\ndot = l1.graph(c1, r1, Method(\"zig_zig()\"), l2, a2, r2)\nfor subtree in w1, x1, y1, z1, w2, x2, y2, z2:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Wir bewegen den Knoten $a$ an die Wurzel. $b$ wird mit $c$ als rechtes Kind an $R$ angefügt, wobei $c$ als seinen linken Teilbaum $y$ hat. Die Ordnungsbedingung bleibt erhalten, da $c > b > a$ und $y > c > b$ ist.\n\nWir definieren\n\n$$k < b \\Rightarrow \\langle L, \\mathrm{Node}(c, \\mathrm{Node}(b, \\mathrm{Node}(a, w, x), y), z), R\\rangle.\\mathrm{splay\\_step}(k) =$$\n$$= \\langle L, \\mathrm{Node}(a, w, x), R.\\mathrm{insert\\_left}(\\mathrm{Node}(b, \\mathrm{Node}(c, y, z)))\\rangle.\\mathrm{splay\\_step}(k)$$\n\nWir schreiben in der Implementierung wieder nur die nötigen Referenzen um. Dies sind einfach einige zusätzliche Schritte im Vergleich zu `_zig` und `_zag`.", "_____no_output_____" ] ], [ [ "def _zig_zig(self, max_less, min_greater):\n # self = Node(c, Node(b, Node(a, w, x), y), z)\n min_greater.left = self.left\n new_min_greater = self.left\n # new min_greater = Node(b, Node(a, w, x), y)\n new_self = new_min_greater.left\n # new_self = Node(a, w, x)\n self.left = new_min_greater.right\n # self = Node(c, y, z)\n new_min_greater.left = None\n # new_min_greater = Node(b, Nil, y)\n new_min_greater.right = self\n # new_min_greater = Node(b, Nil, Node(c, y, z))\n return max_less, new_self, new_min_greater\n\nNode._zig_zig = _zig_zig\ndel _zig_zig", "_____no_output_____" ] ], [ [ "Wir bezeichnen die gleiche Situation mit rechtem Kind und rechtem Enkel als *Zag-Zag*:", "_____no_output_____" ] ], [ [ "# flake8: noqa\nw1 = Node(\"w\", None, None); x1 = Node(\"x\", None, None); y1 = Node(\"y\", None, None); z1 = Node(\"z\", None, None)\na1 = Node(\"a\", y1, z1); b1 = Node(\"b\", x1, a1); c1 = Node(\"c\", w1, b1)\nl1 = TempTree(\"L\", None, False); r1 = TempTree(\"R\", None, True)\n\nw2 = Node(\"w\", None, None); x2 = Node(\"x\", None, None); y2 = Node(\"y\", None, None); z2 = Node(\"z\", None, None)\na2 = Node(\"a\", y2, z2); c2 = Node(\"c\", w2, x2); b2 = Node(\"b\", c2, None)\nl2 = TempTree(\"L\", b2, False); r2 = TempTree(\"R\", None, True)\n\ndot = l1.graph(c1, r1, Method(\"zag_zag()\"), l2, a2, r2)\nfor subtree in w1, x1, y1, z1, w2, x2, y2, z2:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Der Splay-Schritt ist ähnlich definiert und implementiert.\n\n$$k > b \\Rightarrow \\langle L, \\mathrm{Node}(c, w, \\mathrm{Node}(b, x, \\mathrm{Node}(a, y, z))), R\\rangle.\\mathrm{splay\\_step}(k) = $$\n$$= \\langle L.\\mathrm{insert\\_right}(\\mathrm{Node}(b, \\mathrm{Node}(c, w, x), \\mathrm{Nil})), \\mathrm{Node}(a, y, z), R\\rangle.\\mathrm{splay\\_step}(k)$$", "_____no_output_____" ] ], [ [ "def _zag_zag(self, max_less, min_greater):\n # self = Node(c, w, Node(b, x, Node(a, y, z)))\n max_less.right = self.right\n new_max_less = self.right\n # new_max_less = Node(b, x, Node(a, y, z))\n new_self = new_max_less.right\n # new_self = Node(a, y, z)\n self.right = new_max_less.left\n # self = Node(c, w, x)\n new_max_less.right = None\n # new_max_less = Node(b, x, Nil)\n new_max_less.left = self\n # new_max_less = Node(b, Node(c, w, x), Nil)\n return new_max_less, new_self, min_greater\n\nNode._zag_zag = _zag_zag\ndel _zag_zag", "_____no_output_____" ] ], [ [ "### Zig-Zag und Zag-Zig\n\nZuletzt behandeln wir den Fall, dass der Elternknoten ein linkes Kind, der Knoten selbst aber ein rechtes Kind ist. Die Operation auf diese Situation nennen wir *Zig-Zag*. Für diese Operation brauchen wir erstmalig sowohl $L$ als auch $R$:", "_____no_output_____" ] ], [ [ "# flake8: noqa\nw1 = Node(\"w\", None, None); x1 = Node(\"x\", None, None)\ny1 = Node(\"y\", None, None); z1 = Node(\"z\", None, None)\na1 = Node(\"a\", x1, y1); b1 = Node(\"b\", w1, a1); c1 = Node(\"c\", b1, z1)\nl1 = TempTree(\"L\", None, False); r1 = TempTree(\"R\", None, True)\n\nw2 = Node(\"w\", None, None); x2 = Node(\"x\", None, None)\ny2 = Node(\"y\", None, None); z2 = Node(\"z\", None, None)\na2 = Node(\"a\", x2, y2); b2 = Node(\"b\", w2, None); c2 = Node(\"c\", None, z2)\nl2 = TempTree(\"L\", b2, False); r2 = TempTree(\"R\", c2, True)\n\ndot = l1.graph(c1, r1, Method(\"zig_zag()\"), l2, a2, r2)\nfor subtree in w1, x1, y1, z1, w2, x2, y2, z2:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Wir bewegen den Knoten $a$ an die Stelle von $c$, dabei werden $b$ und $c$ respektive an $L$ und $R$ angefügt, die ja jeweils kleiner bzw. größer als $a$ sind.\n\nWir definieren\n\n$$b < k < c \\Rightarrow \\langle L, \\mathrm{Node}(c, \\mathrm{Node}(b, w, \\mathrm{Node}(a, x, y)), z), R\\rangle.\\mathrm{splay\\_step}(k) =$$\n$$= \\langle L.\\mathrm{insert\\_right}(\\mathrm{Node}(b, w, \\mathrm{Nil})), \\mathrm{Node}(a, x, y), R.\\mathrm{insert\\_left}(\\mathrm{Node}(c, \\mathrm{Nil}, z))\\rangle.\\mathrm{splay\\_step}(k)$$\n\nIn Code haben wir", "_____no_output_____" ] ], [ [ "def _zig_zag(self, max_less, min_greater):\n # self = Node(c, Node(b, w, Node(a, x, y)), z)\n max_less.right = self.left\n new_max_less = self.left\n # new_max_less = Node(b, w, Node(a, x, y))\n min_greater.left = self\n new_min_greater = self\n # new_min_greater = Node(c, Node(b, w, Node(a, x, y)), z)\n new_self = self.left.right\n # new_self = Node(a, x, y)\n new_max_less.right = None\n # new_max_less = Node(b, w, Nil)\n new_min_greater.left = None\n # new_min_greater = Node(c, Nil, z)\n return new_max_less, new_self, new_min_greater\n\nNode._zig_zag = _zig_zag\ndel _zig_zag", "_____no_output_____" ] ], [ [ "In umgekehrter Reihenfolge, d.h. der Elternknoten ist das rechte Kind, der Knoten das linke Kind, haben wir die Operation *Zag-Zig* mit", "_____no_output_____" ] ], [ [ "# flake8: noqa\nw1 = Node(\"w\", None, None); x1 = Node(\"x\", None, None)\ny1 = Node(\"y\", None, None); z1 = Node(\"z\", None, None)\na1 = Node(\"a\", x1, y1); b1 = Node(\"b\", a1, z1); c1 = Node(\"c\", w1, b1)\nl1 = TempTree(\"L\", None, False); r1 = TempTree(\"R\", None, True)\n\nw2 = Node(\"w\", None, None); x2 = Node(\"x\", None, None)\ny2 = Node(\"y\", None, None); z2 = Node(\"z\", None, None)\na2 = Node(\"a\", x2, y2); b2 = Node(\"b\", None, z2); c2 = Node(\"c\", w2, None)\nl2 = TempTree(\"L\", c2, False); r2 = TempTree(\"R\", b2, True)\n\ndot = l1.graph(c1, r1, Method(\"zag_zig()\"), l2, a2, r2)\nfor subtree in w1, x1, y1, z1, w2, x2, y2, z2:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Formal schreiben wir\n\n$$c < k < b \\Rightarrow \\langle L, \\mathrm{Node}(c, w, \\mathrm{Node}(b, \\mathrm{Node}(a, x, y), z)), R\\rangle.\\mathrm{splay\\_step}(k) =$$\n$$= \\langle L.\\mathrm{insert\\_right}(\\mathrm{Node}(c, w, \\mathrm{Nil})), \\mathrm{Node}(a, x, y), R.\\mathrm{insert\\_left}(\\mathrm{Node}(b, \\mathrm{Nil}, z))\\rangle.\\mathrm{splay\\_step}(k)$$\n\nund in Code", "_____no_output_____" ] ], [ [ "def _zag_zig(self, max_less, min_greater):\n # self = Node(c, w, Node(b, Node(a, x, y), z))\n max_less.right = self\n new_max_less = self\n # new_max_less = Node(c, w, Node(b, Node(a, x, y), z))\n min_greater.left = self.right\n new_min_greater = self.right\n # new_min_greater = Node(b, Node(a, x, y), z)\n new_self = self.right.left\n # new_self = Node(a, x, y)\n new_max_less.right = None\n # new_max_less = Node(c, w, Nil)\n new_min_greater.left = None\n # new_min_greater = Node(b, Nil, z)\n return new_max_less, new_self, new_min_greater\n\nNode._zag_zig = _zag_zig\ndel _zag_zig", "_____no_output_____" ] ], [ [ "### Vergleich beliebiger Nutzlasten\n\nWir müssen, um später Mengen, die Elemente unterschiedlicher Typen enthalten, zu unterstützen, dazu in der Lage sein, beliebige Nutzlasten zu vergleichen. Dazu versuchen wir den direkten Vergleich, und vergleichen, wenn das nicht funktioniert, am Klassennamen. So kommen wertgleiche Fließkomma- und Ganzzahlen nur einmal in die Menge (dies ist auch bei Python-Mengen so). Die Methoden, die wir dazu schreiben, geben wir der Klasse `Node` mit, um so wenig wie möglich in den Namespace zu laden, und somit die Einsetzbarkeit zu erhöhen. `_arb_gt(x, y)` überprüft, ob im Sinne dieses Vergleichs `x` $>$ `y` ist.", "_____no_output_____" ] ], [ [ "def _arb_gt(self, x, y):\n try:\n return y < x\n except TypeError:\n return type(x).__name__ > type(y).__name__\n\nNode._arb_gt = _arb_gt\ndel _arb_gt", "_____no_output_____" ] ], [ [ "`_arb_lt(x, y)` überprüft `x` $<$ `y`…", "_____no_output_____" ] ], [ [ "def _arb_lt(self, x, y):\n try:\n return x < y\n except TypeError:\n return type(x).__name__ < type(y).__name__\n\nNode._arb_lt = _arb_lt\ndel _arb_lt", "_____no_output_____" ] ], [ [ "…und `_arb_eq(x, y)` überprüft `x == y`.", "_____no_output_____" ] ], [ [ "def _arb_eq(self, x, y):\n try:\n return x == y\n except TypeError:\n return False\n\nNode._arb_eq = _arb_eq\ndel _arb_eq", "_____no_output_____" ] ], [ [ "### Verkettung der Schritte\n\nDer formalen Definition fehlt noch der Basisfall, wenn die Wurzel die zu splayende Nutzlast enthält. Wir fügen dann $L$ und $R$ an die neue Wurzel an – die Knoten in $L$ und $R$ waren ja gerade eben kleiner bzw. größer als die Wurzel. Wir fügen dabei die Teilbäume, die die Wurzel jetzt noch hat, in $L$ und $R$ ein; links von der Wurzel sind alle Nutzlasten, die größer als $L$ sind, und rechts sind alle, die kleiner als $R$ sind.", "_____no_output_____" ] ], [ [ "# flake8: noqa\nx1 = Node(\"x\", None, None); y1 = Node(\"y\", None, None); a1 = Node(\"a\", x1, y1)\nl1 = TempTree(\"L\", None, False); r1 = TempTree(\"R\", None, True)\n\nx2 = Node(\"x\", None, None); y2 = Node(\"y\", None, None)\nl2 = TempTree(\"L\", x2, False); r2 = TempTree(\"R\", y2, True)\na2 = Node(\"a\", l2, r2)\n\ndot = l1.graph(a1, r1, Method(\"finish()\"), a2)\nfor subtree in x1, y1, x2, y2:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Wir definieren:\n\n$$\\langle L, \\mathrm{Node}(a, x, y), R\\rangle.\\mathrm{splay\\_step}(a) = \\langle\\mathrm{Nil}, \\mathrm{Node}(a, L.\\mathrm{insert\\_right}(x), R.\\mathrm{insert\\_left}(y)), \\mathrm{Nil}\\rangle$$\n\nWir müssen allerdings auch den Basisfall betrachten, dass wir feststellen, dass der Knoten nicht vorhanden ist, weil da, wo der Knoten stünde, keine Knoten mehr sind. In diesem Fall müssen wir nur noch den anderen Teilbaum anfügen.\n\n$$\\begin{aligned}\nk < a &\\Rightarrow \\langle L, \\mathrm{Node}(a, \\mathrm{Nil}, y), R\\rangle.\\mathrm{splay\\_step}(k) = \\langle\\mathrm{Nil}, \\mathrm{Node}(a, L, R.\\mathrm{insert\\_left}(y)), \\mathrm{Nil}\\rangle \\\\\nk > a &\\Rightarrow \\langle L, \\mathrm{Node}(a, x, \\mathrm{Nil}), R\\rangle.\\mathrm{splay\\_step}(k) = \\langle\\mathrm{Nil}, \\mathrm{Node}(a, L.\\mathrm{insert\\_right}(x), R), \\mathrm{Nil}\\rangle\n\\end{aligned}$$\n\nIn der Implementierung wählen wir so lange den angemessenen Schritt aus und führen ihn durch, bis wir an den gesuchten Knoten kommen oder erfolglos an ein Blatt stoßen. So vermeiden wir Funktionsaufrufe und die Grenzen von Rekursionstiefe. Falls der gesuchte Knoten noch genau eine Ebene entfernt ist, so führen wir Zig bzw. Zag durch. In diesem Fall unterscheiden wir:\n\n|Linkes Kind|Rechtes Kind|\n|:----------|:-----------|\n|Zig |Zag |\n\nFalls er noch mindestens zwei Ebenen entfernt ist, so unterscheiden wir:\n\n|Kind vs. Enkel |Linkes Kind|Rechtes Kind|\n|----------------:|:----------|:-----------|\n|**Linker Enkel** |Zig-Zig |Zag-Zig |\n|**Rechter Enkel**|Zig-Zag |Zag-Zag |\n\nUm diese Implementierung später besser mit anderen rekursiv implementierten Datenstrukturen vergleichen zu können, implementieren wir den `_splay_step` jetzt auch rekursiv:", "_____no_output_____" ] ], [ [ "def _splay_step(self, max_less, min_greater, payload):\n if self._arb_lt(payload, self.payload):\n if self.left is None:\n return max_less, self, min_greater\n if self._arb_lt(payload, self.left.payload) \\\n and self.left.left is not None:\n new_max_less, new_self, new_min_greater = \\\n self._zig_zig(max_less, min_greater)\n return new_self._splay_step(new_max_less, new_min_greater, payload)\n if self._arb_gt(payload, self.left.payload) \\\n and self.left.right is not None:\n new_max_less, new_self, new_min_greater = \\\n self._zig_zag(max_less, min_greater)\n return new_self._splay_step(new_max_less, new_min_greater, payload)\n return self._zig(max_less, min_greater)\n if self._arb_gt(payload, self.payload):\n if self.right is None:\n return max_less, self, min_greater\n if self._arb_gt(payload, self.right.payload) \\\n and self.right.right is not None:\n new_max_less, new_self, new_min_greater = \\\n self._zag_zag(max_less, min_greater)\n return new_self._splay_step(new_max_less, new_min_greater, payload)\n if self._arb_lt(payload, self.right.payload) \\\n and self.right.left is not None:\n new_max_less, new_self, new_min_greater = \\\n self._zag_zig(max_less, min_greater)\n return new_self._splay_step(new_max_less, new_min_greater, payload)\n return self._zag(max_less, min_greater)\n return max_less, self, min_greater\n\nNode._splay_step = _splay_step\ndel _splay_step", "_____no_output_____" ] ], [ [ "In der Zusammensetzung `_splay` fügen wir noch die Teilbäume von der neuen Wurzel an $L, R$ an und setzen $L, R$ als Teilbäume dieser neuen Wurzel. Wir benutzen statt $L, R$ nur einen Baum `set_aside`, bei dem wir auf der entsprechenden Seite anfügen.", "_____no_output_____" ] ], [ [ "def _splay(self, payload):\n set_aside = Node(None, None, None)\n max_less, new_self, min_greater = \\\n self._splay_step(set_aside, set_aside, payload)\n max_less.right = new_self.left\n min_greater.left = new_self.right\n new_self.left = set_aside.right\n new_self.right = set_aside.left\n return new_self\n\nNode._splay = _splay\ndel _splay", "_____no_output_____" ] ], [ [ "Das nächste Beispiel zeigt, wie ein Splay aus einem schlechtestmöglich balancierten Baum einen deutlich besser balancierten Baum machen kann:", "_____no_output_____" ] ], [ [ "# flake8: noqa\na1 = Node(\"a\", None, None); c1 = Node(\"c\", None, None); e1 = Node(\"e\", None, None); g1 = Node(\"g\", None, None)\nj1 = Node(\"j\", None, None); l1 = Node(\"l\", None, None); n1 = Node(\"n\", None, None); p1 = Node(\"p\", None, None)\nb1 = Node(\"b\", a1, c1); d1 = Node(\"d\", b1, e1); f1 = Node(\"f\", d1, g1); h1 = Node(\"h\", f1, j1)\nk1 = Node(\"k\", h1, l1); m1 = Node(\"m\", k1, n1); o1 = Node(\"o\", m1, p1)\n\na2 = Node(\"a\", None, None); c2 = Node(\"c\", None, None); e2 = Node(\"e\", None, None); g2 = Node(\"g\", None, None)\nj2 = Node(\"j\", None, None); l2 = Node(\"l\", None, None); n2 = Node(\"n\", None, None); p2 = Node(\"p\", None, None)\nb2 = Node(\"b\", a2, c2); d2 = Node(\"d\", b2, e2); f2 = Node(\"f\", d2, g2); h2 = Node(\"h\", f2, j2)\nk2 = Node(\"k\", h2, l2); m2 = Node(\"m\", k2, n2); o2 = Node(\"o\", m2, p2)\n\ndot = o1.graph(Method(\"splay()\"), o2._splay(\"b\"))\nfor subtree in a1, c1, e1, g1, j1, l1, n1, p1, a2, c2, e2, g2, j2, l2, n2, p2:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Ein anderes Beispiel enthält alle Schritte außer Zag:", "_____no_output_____" ] ], [ [ "# flake8: noqa\nj1 = Node(\"j\", None, None); l1 = Node(\"l\", None, None); n1 = Node(\"n\", None, None); p1 = Node(\"p\", None, None)\ng1 = Node(\"g\", None, None); e1 = Node(\"e\", None, None); r1 = Node(\"r\", None, None); c1 = Node(\"c\", None, None)\na1 = Node(\"a\", None, None); t1 = Node(\"t\", None, None); v1 = Node(\"v\", None, None)\nk1 = Node(\"k\", j1, l1); m1 = Node(\"m\", k1, n1); o1 = Node(\"o\", m1, p1); h1 = Node(\"h\", g1, o1)\nf1 = Node(\"f\", e1, h1); q1 = Node(\"q\", f1, r1); d1 = Node(\"d\", c1, q1); b1 = Node(\"b\", a1, d1)\ns1 = Node(\"s\", b1, t1); u1 = Node(\"u\", s1, v1)\n\nj2 = Node(\"j\", None, None); l2 = Node(\"l\", None, None); n2 = Node(\"n\", None, None); p2 = Node(\"p\", None, None)\ng2 = Node(\"g\", None, None); e2 = Node(\"e\", None, None); r2 = Node(\"r\", None, None); c2 = Node(\"c\", None, None)\na2 = Node(\"a\", None, None); t2 = Node(\"t\", None, None); v2 = Node(\"v\", None, None)\nk2 = Node(\"k\", j2, l2); m2 = Node(\"m\", k2, n2); o2 = Node(\"o\", m2, p2); h2 = Node(\"h\", g2, o2)\nf2 = Node(\"f\", e2, h2); q2 = Node(\"q\", f2, r2); d2 = Node(\"d\", c2, q2); b2 = Node(\"b\", a2, d2)\ns2 = Node(\"s\", b2, t2); u2 = Node(\"u\", s2, v2)\n\ndot = u1.graph(Method(\"splay()\"), u2._splay(\"k\"))\nfor subtree in a1, c1, e1, g1, j1, l1, n1, p1, r1, t1, v1, a2, c2, e2, g2, j2, l2, n2, p2, r2, t2, u2:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Wir betrachten zuletzt das folgende Beispiel, um Zag abgedeckt zu haben:", "_____no_output_____" ] ], [ [ "# flake8: noqa\na1 = Node(\"a\", None, None); c1 = Node(\"c\", None, None); e1 = Node(\"e\", None, None)\nd1 = Node(\"d\", c1, e1); b1 = Node(\"b\", a1, d1)\n\na2 = Node(\"a\", None, None); c2 = Node(\"c\", None, None); e2 = Node(\"e\", None, None)\nd2 = Node(\"d\", c2, e2); b2 = Node(\"b\", a2, d2)\n\ndot = b1.graph(Method(\"splay()\"), b2._splay(\"d\"))\nfor subtree in a1, c1, e1, a2, c2, e2:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "## Standardoperationen\n\nWir definieren für den Splay Tree als nächstes die grundlegenden Operationen auf Bäume: Einfügen, Löschen, auf das Vorhandensein eines Elements überprüfen, und auf das Leersein überprüfen.\n\n### Einfügen\n\nWir definieren das Einfügen eines Elementes, bei dem in einen bestehenden Baum eine neue Nutzlast eingefügt wird, wodurch sich der Baum i.A. verändert.\n\n$$\\mathrm{Node}.\\mathrm{insert}: \\mathrm{Payload} \\to \\mathrm{Node}$$\n\nBeim Einfügen traversieren wir nicht, wie bei den meisten Bäumen und auch bei der Verwendung des Bottom-Up-Splaying-Ansatzes, den Baum hinunter, sondern splayen an dem Element, das wir einfügen wollen. Es kann sein, dass die Wurzel des gesplayten Baums schon das einzufügende Element ist, in diesem Fall sind wir fertig. Wir bezeichnen den Baum mit $B$ und das neue Element mit $k$. Ist der Baum noch leer, so brauchen wir nur die Wurzel setzen:\n\n$$\\begin{aligned}\nB = \\mathrm{Nil} &\\Rightarrow B.\\mathrm{insert}(k) = \\mathrm{Node}(k, \\mathrm{Nil}, \\mathrm{Nil}) \\\\\nB.\\mathrm{splay}(k) = \\mathrm{Node}(k, x, y) &\\Rightarrow B.\\mathrm{insert}(k) = B.\\mathrm{splay}(k)\n\\end{aligned}$$\n\nAndernfalls ist die neue Wurzel genau das Element, das im ganzen Baum das nächstgrößere oder nächstkleinere als das einzufügende Element ist, oder formaler:\n\n$$B.\\mathrm{splay}(k) = \\mathrm{Node}(x, y, z) \\Rightarrow x = k \\lor x = \\max(\\{\\kappa \\in B: \\kappa < k\\}) \\lor x = \\min(\\{\\kappa \\in B: \\kappa > k\\})$$\n\nIn diesen beiden Fällen setzen wir das einzufügende Element $k$ als Wurzel. Im Fall, dass $k$ kleiner als die Wurzel des gesplayten existierenden Baums $B' = \\mathrm{Node}(x, y, z)$ ist, sind trotzdem alle Elemente im linken Teilbaum $y$ von $B'$ kleiner als $k$ und wir setzen diesen als linken Teilbaum von $k$. Wir setzen die Wurzel $x$ von $B'$ als rechten Teilbaum, da sie, wie auch alle Elemente des rechten Teilbaums $z$ von $B'$ größer als $k$ sind. Dabei setzen wir den linken Teilbaum von $x$ auf $\\mathrm{Nil}$.\n\n$$B.\\mathrm{splay}(k) = \\mathrm{Node}(x, y, z) \\land k < x \\Rightarrow B.\\mathrm{insert}(k) = \\mathrm{Node}(k, y, \\mathrm{Node}(x, \\mathrm{Nil}, z))$$\n\noder graphisch:", "_____no_output_____" ] ], [ [ "# flake8: noqa\nB = Node(\"B\", None, None); k1 = Node(\"k\", None, None)\ny2 = Node(\"y\", None, None); z2 = Node(\"z\", None, None); x2 = Node(\"x\", y2, z2); k2 = Node(\"k\", None, None)\ny3 = Node(\"y\", None, None); z3 = Node(\"z\", None, None); x3 = Node(\"x\", None, z3); k3 = Node(\"k\", y3, x3)\n\ndot = k1.graph(B, Method(\"B.splay(k)\"), k2, x2, Method(\"x.insert(k) where y < k < x\"), k3)\nfor subtree in B, y2, z2, y3, z3:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Im Fall, dass $k$ größer als die Wurzel $x$ des gesplayten Baums $B' = \\mathrm{Node}(x, y, z)$ ist, sind umgekehrt alle Elemente in dessen rechten Teilbaum $z$ größer als $k$, und wir setzen die Wurzel dieses Baumes $x$ als linken Teilbaum des neuen Elements $k$, wobei dieser Knoten dann als linken Teilbaum $y$ hat, als rechten Teilbaum $\\mathrm{Nil}$.\n\n$$B.\\mathrm{splay}(k) = \\mathrm{Node}(x, y, z) \\land k > x \\Rightarrow B.\\mathrm{insert}(k) = \\mathrm{Node}(k, \\mathrm{Node}(x, y, \\mathrm{Nil}), z)$$\n\nund graphisch:", "_____no_output_____" ] ], [ [ "# flake8: noqa\nB = Node(\"B\", None, None); k1 = Node(\"k\", None, None)\ny2 = Node(\"y\", None, None); z2 = Node(\"z\", None, None); x2 = Node(\"x\", y2, z2); k2 = Node(\"k\", None, None)\ny3 = Node(\"y\", None, None); z3 = Node(\"z\", None, None); x3 = Node(\"x\", y3, None); k3 = Node(\"k\", x3, z3)\n\ndot = B.graph(k1, Method(\"B.splay(k)\"), x2, k2, Method(\"x.insert(k) where y < k < x\"), k3)\nfor subtree in B, y2, z2, y3, z3:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ], [ "def insert(self, payload):\n self = self._splay(payload)\n if self._arb_eq(payload, self.payload):\n return self\n if self._arb_lt(payload, self.payload):\n tmp = self.left\n self.left = None\n return Node(payload, tmp, self)\n tmp = self.right\n self.right = None\n return Node(payload, self, tmp)\n\nNode.insert = insert\ndel insert", "_____no_output_____" ] ], [ [ "Für den leeren Baum brauchen wir nur das Element in einen neuen Knoten setzen. Wir definieren – unter anderem zur Betrachtung des Falls des leeren Baumes – die Klasse `SplayTree`, die das Management des leeren Baums wie auch der Tatsache, dass sich bei einem Splay die Wurzel ändert, nach außen vereinfacht.", "_____no_output_____" ] ], [ [ "class SplayTree:\n def __init__(self):\n self.tree = None\n\n def insert(self, payload):\n if self.tree is None:\n self.tree = Node(payload, None, None)\n else:\n self.tree = self.tree.insert(payload)", "_____no_output_____" ] ], [ [ "Für den `SplayTree` definieren wir außerdem `graph`, um `Node.graph` zu exponieren.", "_____no_output_____" ] ], [ [ "def graph(self):\n if self.tree is None:\n return graphviz.Digraph()\n return self.tree.graph()\n\nSplayTree.graph = graph\ndel graph", "_____no_output_____" ] ], [ [ "Einige Beispiele zeigen das Einsetzen von Knoten in Splay Trees:", "_____no_output_____" ] ], [ [ "my_splay = SplayTree()\nmy_splay.insert(\"a\")\nmy_splay.graph()", "_____no_output_____" ], [ "my_splay.insert(\"c\")\nmy_splay.graph()", "_____no_output_____" ], [ "my_splay.insert(\"b\")\nmy_splay.graph()", "_____no_output_____" ] ], [ [ "### Entfernen\n\nWir definieren als nächstes das Entfernen eines Elementes, bei dem ebenfalls eine Nutzlast aus einem bestehenden Baum entfernt wird, wobei sich der Baum i.A. verändert.\n\n$$\\mathrm{Node}.\\mathrm{remove}: \\mathrm{Payload} \\to \\mathrm{Node}$$\n\nWir splayen wieder am zu entfernenden Element und haben dann einen Baum, der das zu entfernende Element als Wurzel hat. Sollte sich nach dem Splayen herausstellen, dass das Element nicht vorhanden ist, werfen wir einen `KeyError`, [da sich so auch die Mengen in Python verhalten](https://docs.python.org/3.7/library/stdtypes.html#set \"Python Software Foundation (2020): The Python Standard Library/Built-in Types/set, Python Documentation\"). In der Definition schreiben wir $\\downarrow$ für das Undefinierte. Dies tritt auch ein, wenn der Baum leer ist:\n\n$$\\begin{aligned}\nB = \\mathrm{Nil} &\\Rightarrow B.\\mathrm{remove}(k)\\downarrow \\\\\nB.\\mathrm{splay}(k) \\neq \\mathrm{Node}(k, x, y) &\\Rightarrow B.\\mathrm{remove}(k)\\downarrow\n\\end{aligned}$$\n\nAndernfalls überprüfen wir, ob ein Teilbaum des gesplayten Baums leer ist. In diesem Fall ist der neue Baum einfach der andere Teilbaum.\n\n$$\\begin{aligned}\nB.\\mathrm{splay}(k) = \\mathrm{Node}(k, \\mathrm{Nil}, x) &\\Rightarrow B.\\mathrm{remove}(k) = x \\\\\nB.\\mathrm{splay}(k) = \\mathrm{Node}(k, x, \\mathrm{Nil}) &\\Rightarrow B.\\mathrm{remove}(k) = x\n\\end{aligned}$$\n\nIst das nicht der Fall, so sorgen wir dafür, dass der rechte Teilbaum des gesplayten Baums keinen linken Teilbaum mehr hat, sodass wir den linken Teilbaum des gesplayten Baums anfügen können. Eine Grafik illustriert, was gemeint ist:", "_____no_output_____" ] ], [ [ "# flake8: noqa\nB = Node(\"B\", None, None)\nv1 = Node(\"v\", None, None); w1 = Node(\"w\", None, None); y1 = Node(\"y\", None, None); x1 = Node(\"x\", w1, y1); k1 = Node(\"k\", v1, x1)\nv2 = Node(\"v\", None, None); y2 = Node(\"y'\", None, None); x2 = Node(\"x'\", None, y2); k2 = Node(\"k\", v2, x2)\nv3 = Node(\"v\", None, None); y3 = Node(\"y'\", None, None); x3 = Node(\"x'\", v3, y3)\n\ndot = B.graph(Method(\"B.splay(k)\"), k1, Method(\"x.splay(k)\"), k2, Method(\"k.remove(k)\"), x3)\nfor subtree in B, v1, w1, y1, v2, y2, v3, y3:\n dot.node(str(id(subtree)), shape=\"triangle\")\ndot", "_____no_output_____" ] ], [ [ "Wir machen aus dem Baum $\\mathrm{Node}(x, w, y)$ den Baum $\\mathrm{Node}(x', \\mathrm{Nil}, y')$, indem wir an $k$ splayen. Da das Minimum aus $\\mathrm{Node}(x, w, y)$ größer $k$ ist, muss dann gerade dieses Minimum die Wurzel ($x'$) werden und kann keinen linken Teilbaum mehr haben.\n\n$$B.\\mathrm{splay}(k) = \\mathrm{Node}(k, v, \\mathrm{Node}(x, w, y)) \\land \\mathrm{Node}(x, w, y).\\mathrm{splay}(k) = \\mathrm{Node}(x', \\mathrm{Nil}, y') \\Rightarrow B.\\mathrm{remove}(k) = \\mathrm{Node}(x', v, y')$$\n\nFür `Node` implementieren wir:", "_____no_output_____" ] ], [ [ "def remove(self, payload):\n self = self._splay(payload)\n if not self._arb_eq(payload, self.payload):\n return False, self\n if self.left is None:\n return True, self.right\n if self.right is None:\n return True, self.left\n tmp = self.left\n self = self.right._splay(payload)\n self.left = tmp\n return True, self\n\nNode.remove = remove\ndel remove", "_____no_output_____" ] ], [ [ "Wir werfen in der Implementierung erst auf Ebene von `SplayTree` den `KeyError`, um im Baum noch aufräumen zu können. Der Nutzer könnte ja im Falle eines `KeyError`s diesen auffangen wollen und die Menge trotzdem noch benutzen wollen.", "_____no_output_____" ] ], [ [ "def remove(self, payload):\n if self.tree is None:\n raise KeyError(payload)\n rc, self.tree = self.tree.remove(payload)\n if not rc:\n raise KeyError(payload)\n\nSplayTree.remove = remove\ndel remove", "_____no_output_____" ] ], [ [ "Einige Beispiele zeigen das Entfernen von Elementen.", "_____no_output_____" ] ], [ [ "my_splay = SplayTree()\nfor letter in [\"a\", \"c\", \"b\"]:\n my_splay.insert(letter)\nmy_splay.graph()", "_____no_output_____" ], [ "my_splay.remove(\"b\")\nmy_splay.graph()", "_____no_output_____" ], [ "my_splay.remove(\"a\")\nmy_splay.graph()", "_____no_output_____" ] ], [ [ "### Finden\n\nWir definieren als nächstes das Überprüfen eines Baumes auf ein Element. In unserer Definition wird ein Tupel aus dem Vorhandensein und der neuen Wurzel zurückgegeben.\n\n$$\\mathrm{Node}.\\mathrm{contains}: \\mathrm{Payload} \\to \\langle\\mathbb{B}, \\mathrm{Node}\\rangle$$\n\nWir splayen am gesuchten Element und können schon an der Wurzel erkennen, ob das Element vorhanden ist. Noch einfacher haben wir es, wenn keine Elemente im Baum sind:\n\n$$\\begin{aligned}\nB = \\mathrm{Nil} &\\Rightarrow B.\\mathrm{contains}(k) = (\\mathrm{false}, \\mathrm{Nil}) \\\\\nB.\\mathrm{splay}(k) = \\mathrm{Node}(k, y, z) &\\Rightarrow B.\\mathrm{contains}(k) = (\\mathrm{true}, \\mathrm{Node}(k, y, z)) \\\\\nB.\\mathrm{splay}(k) = \\mathrm{Node}(x, y, z) \\land k \\neq x &\\Rightarrow B.\\mathrm{contains}(k) = (\\mathrm{false}, \\mathrm{Node}(x, y, z))\n\\end{aligned}$$\n\nWir haben für `Node`", "_____no_output_____" ] ], [ [ "def contains(self, payload):\n self = self._splay(payload)\n return self._arb_eq(payload, self.payload), self\n\nNode.contains = contains\ndel contains", "_____no_output_____" ] ], [ [ "und für den `SplayTree`", "_____no_output_____" ] ], [ [ "def contains(self, payload):\n if self.tree is None:\n return False\n contains, self.tree = self.tree.contains(payload)\n return contains\n\nSplayTree.contains = contains\ndel contains", "_____no_output_____" ] ], [ [ "Beispiele zeigen uns:", "_____no_output_____" ] ], [ [ "my_splay = SplayTree()\nfor letter in [\"a\", \"c\", \"b\"]:\n my_splay.insert(letter)\nmy_splay.graph()", "_____no_output_____" ], [ "my_splay.contains(\"a\")", "_____no_output_____" ], [ "my_splay.graph()", "_____no_output_____" ], [ "my_splay.contains(\"d\")", "_____no_output_____" ], [ "my_splay.graph()", "_____no_output_____" ] ], [ [ "### Leerüberprüfung\n\nWir definieren zuletzt, wie wir überprüfen, ob der Baum leer ist.\n\n$$\\mathrm{Node}.\\mathrm{is\\_empty}: \\langle\\rangle \\to \\mathbb{B}$$\n$$\\mathrm{Node}.\\mathrm{is\\_empty}() = (\\mathrm{Node} = \\mathrm{Nil})$$\n\nDie Implementierung findet von `SplayTree` aus statt.", "_____no_output_____" ] ], [ [ "def is_empty(self):\n return self.tree is None\n\nSplayTree.is_empty = is_empty\ndel is_empty", "_____no_output_____" ], [ "my_splay = SplayTree()\nmy_splay.is_empty()", "_____no_output_____" ], [ "my_splay.insert(\"a\")\nmy_splay.is_empty()", "_____no_output_____" ] ], [ [ "## Demonstration\n\nAls kleine Demonstration von `SplayTree` implementieren wir damit die Ermittlung aller Primzahlen bis zu einer Zahl `n` mit dem *Sieb des Eratosthenes*:", "_____no_output_____" ] ], [ [ "def primes(n):\n primes = SplayTree()\n for i in range(2, n + 1):\n primes.insert(i)\n for i in range(2, n + 1):\n for j in range(2 * i, n + 1, i):\n try:\n primes.remove(j)\n except KeyError:\n pass\n return primes", "_____no_output_____" ] ], [ [ "Da die Zahlen sequenziell betrachtet wurden, ist der Baum zunächst maximal unbalanciert:", "_____no_output_____" ] ], [ [ "tree = primes(25)\ntree.graph()", "_____no_output_____" ] ], [ [ "Wir sehen aber zum Beispiel, dass schon durch einen Splay ein deutlich besser balancierter Baum entsteht:", "_____no_output_____" ] ], [ [ "tree.tree = tree.tree._splay(7)\ntree.graph()", "_____no_output_____" ] ], [ [ "Da wir dieses Notebook noch wiederverwenden, entfernen wir irrelevante Namen aus dem Namespace.", "_____no_output_____" ] ], [ [ "del B, a1, a2, b1, b2, c1, c2, d1, d2, dot, e1, e2, f1, f2, g1, g2, h1, h2, \\\n j1, j2, k1, k2, k3, l1, l2, letter, m1, m2, my_splay, n1, n2, o1, o2, p1, \\\n p2, primes, q1, q2, r1, r2, s1, s2, subtree, t1, t2, tree, v1, v2, v3, \\\n w1, w2, x1, x2, x3, y1, y2, y3, z1, z2, z3", "_____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", "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", "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" ], [ "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" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import keras\nfrom keras.models import Sequential, Model, load_model\n\nfrom keras.layers import Dense, Dropout, Activation, Flatten, Input, Lambda\nfrom keras.layers import Conv2D, MaxPooling2D, AveragePooling2D, Conv1D, MaxPooling1D, LSTM, ConvLSTM2D, GRU, CuDNNLSTM, CuDNNGRU, BatchNormalization, LocallyConnected2D, Permute, TimeDistributed, Bidirectional\nfrom keras.layers import Concatenate, Reshape, Softmax, Conv2DTranspose, Embedding, Multiply\nfrom keras.callbacks import ModelCheckpoint, EarlyStopping, Callback\nfrom keras import regularizers\nfrom keras import backend as K\nfrom keras.utils.generic_utils import Progbar\nfrom keras.layers.merge import _Merge\nimport keras.losses\nfrom keras.datasets import mnist\n\nfrom functools import partial\n\nfrom collections import defaultdict\n\nimport tensorflow as tf\nfrom tensorflow.python.framework import ops\n\nimport isolearn.keras as iso\n\nimport numpy as np\n\nimport tensorflow as tf\nimport logging\nlogging.getLogger('tensorflow').setLevel(logging.ERROR)\n\nimport os\nimport pickle\nimport numpy as np\n\nimport scipy.sparse as sp\nimport scipy.io as spio\n\nimport matplotlib.pyplot as plt\n\nfrom keras.backend.tensorflow_backend import set_session\n\ndef contain_tf_gpu_mem_usage() :\n config = tf.ConfigProto()\n config.gpu_options.allow_growth = True\n sess = tf.Session(config=config)\n set_session(sess)\n\ncontain_tf_gpu_mem_usage()\n\nclass EpochVariableCallback(Callback) :\n \n def __init__(self, my_variable, my_func) :\n self.my_variable = my_variable \n self.my_func = my_func\n \n def on_epoch_begin(self, epoch, logs={}) :\n K.set_value(self.my_variable, self.my_func(K.get_value(self.my_variable), epoch))\n", "Using TensorFlow backend.\n" ], [ "#Load MNIST data\n\ndataset_name = \"mnist_2_vs_4_binary_predictor\"\n\nimg_rows, img_cols = 28, 28\n\nnum_classes = 10\nbatch_size = 32\n\nincluded_classes = [ 2, 4 ]\n\n(x_train, y_train), (x_test, y_test) = mnist.load_data()\n\nkeep_index_train = []\nfor i in range(y_train.shape[0]) :\n if y_train[i] in included_classes :\n keep_index_train.append(i)\n\nkeep_index_test = []\nfor i in range(y_test.shape[0]) :\n if y_test[i] in included_classes :\n keep_index_test.append(i)\n\nx_train = x_train[keep_index_train]\nx_test = x_test[keep_index_test]\ny_train = y_train[keep_index_train]\ny_test = y_test[keep_index_test]\n\nn_train = int((x_train.shape[0] // batch_size) * batch_size)\nn_test = int((x_test.shape[0] // batch_size) * batch_size)\nx_train = x_train[:n_train]\nx_test = x_test[:n_test]\ny_train = y_train[:n_train]\ny_test = y_test[:n_test]\n\nx_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)\nx_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)\n\ninput_shape = (img_rows, img_cols, 1)\n\nx_train = x_train.astype('float32')\nx_test = x_test.astype('float32')\nx_train /= 255\nx_test /= 255\n\nprint(\"x_train.shape = \" + str(x_train.shape))\n\nprint(\"n train samples = \" + str(x_train.shape[0]))\nprint(\"n test samples = \" + str(x_test.shape[0]))\n\ny_train = keras.utils.to_categorical(y_train, num_classes)\ny_test = keras.utils.to_categorical(y_test, num_classes)\n\n#Binarize images\n\ndef _binarize_images(x, val_thresh=0.5) :\n \n x_bin = np.zeros(x.shape)\n x_bin[x >= val_thresh] = 1.\n \n return x_bin\n\nx_train = _binarize_images(x_train, val_thresh=0.5)\nx_test = _binarize_images(x_test, val_thresh=0.5)\n", "x_train.shape = (11776, 28, 28, 1)\nn train samples = 11776\nn test samples = 1984\n" ], [ "#Make binary labels\n\ndigit_train = np.argmax(y_train, axis=-1)\ndigit_test = np.argmax(y_test, axis=-1)\n\ny_train = np.zeros((digit_train.shape[0], 1))\ny_train[digit_train == included_classes[0], 0] = 0\ny_train[digit_train == included_classes[1], 0] = 1\n\ny_test = np.zeros((digit_test.shape[0], 1))\ny_test[digit_test == included_classes[0], 0] = 0\ny_test[digit_test == included_classes[1], 0] = 1\n", "_____no_output_____" ], [ "#Visualize background image distribution\n\npseudo_count = 1.0\n\nx_mean = (np.sum(x_train, axis=(0, 3)) + pseudo_count) / (x_train.shape[0] + pseudo_count)\nx_mean_logits = np.log(x_mean / (1. - x_mean))\n\nf = plt.figure(figsize=(4, 4))\n\nplot_ix = 0\n\nplt.imshow(x_mean, cmap=\"Greys\", vmin=0.0, vmax=1.0, aspect='equal')\n\nplt.xticks([], [])\nplt.yticks([], [])\n\nplt.tight_layout()\nplt.show()\n", "_____no_output_____" ], [ "#Calculate mean training set conservation\n\nentropy = (x_mean * -np.log(x_mean) + (1. - x_mean) * -np.log(1. - x_mean)) / np.log(2.0)\nconservation = 1.0 - entropy\n\nx_mean_conservation = np.mean(conservation)\n\nprint(\"Mean conservation (bits) = \" + str(x_mean_conservation))\n", "Mean conservation (bits) = 0.6241306924499999\n" ], [ "#Calculate mean training set kl-divergence against background\n\nx_train_clipped = np.clip(np.copy(x_train[:, :, :, 0]), 1e-8, 1. - 1e-8)\n\nx_mean_broadcasted = np.tile(np.expand_dims(x_mean, axis=0), (x_train_clipped.shape[0], 1, 1))\n\nkl_divs = (x_train_clipped * np.log(x_train_clipped / x_mean_broadcasted) + (1. - x_train_clipped) * np.log((1. - x_train_clipped) / (1. - x_mean_broadcasted))) / np.log(2.0)\n\nx_mean_kl_divs = np.mean(kl_divs, axis=(1, 2))\nx_mean_kl_div = np.mean(x_mean_kl_divs)\n\nprint(\"Mean KL Div against background (bits) = \" + str(x_mean_kl_div))\n", "Mean KL Div against background (bits) = 0.3753392663167618\n" ], [ "from tensorflow.python.framework import ops\n\n#Stochastic Binarized Neuron helper functions (Tensorflow)\n#ST Estimator code adopted from https://r2rt.com/binary-stochastic-neurons-in-tensorflow.html\n#See Github https://github.com/spitis/\n\ndef bernoulli_sample(x):\n g = tf.get_default_graph()\n with ops.name_scope(\"BernoulliSample\") as name:\n with g.gradient_override_map({\"Ceil\": \"Identity\",\"Sub\": \"BernoulliSample_ST\"}):\n return tf.ceil(x - tf.random_uniform(tf.shape(x)), name=name)\n\[email protected](\"BernoulliSample_ST\")\ndef bernoulliSample_ST(op, grad):\n return [grad, tf.zeros(tf.shape(op.inputs[1]))]\n", "_____no_output_____" ], [ "#Masking and Sampling helper functions\n\ndef sample_image_st(x) :\n p = tf.sigmoid(x)\n\n return bernoulli_sample(p)\n\n#Generator helper functions\ndef initialize_templates(generator, background_matrices) :\n\n embedding_backgrounds = []\n\n for k in range(len(background_matrices)) :\n embedding_backgrounds.append(background_matrices[k].reshape(1, -1))\n\n embedding_backgrounds = np.concatenate(embedding_backgrounds, axis=0)\n\n generator.get_layer('background_dense').set_weights([embedding_backgrounds])\n generator.get_layer('background_dense').trainable = False\n\n#Generator construction function\ndef build_sampler(batch_size, n_rows, n_cols, n_classes=1, n_samples=1) :\n\n #Initialize Reshape layer\n reshape_layer = Reshape((n_rows, n_cols, 1))\n \n #Initialize background matrix\n background_dense = Embedding(n_classes, n_rows * n_cols, embeddings_initializer='zeros', name='background_dense')\n\n #Initialize Templating and Masking Lambda layer\n background_layer = Lambda(lambda x: x[0] + x[1], name='background_layer')\n \n #Initialize Sigmoid layer\n image_layer = Lambda(lambda x: K.sigmoid(x), name='image')\n \n #Initialize Sampling layers\n upsampling_layer = Lambda(lambda x: K.tile(x, [n_samples, 1, 1, 1]), name='upsampling_layer')\n sampling_layer = Lambda(sample_image_st, name='image_sampler')\n permute_layer = Lambda(lambda x: K.permute_dimensions(K.reshape(x, (n_samples, batch_size, n_rows, n_cols, 1)), (1, 0, 2, 3, 4)), name='permute_layer')\n \n def _sampler_func(class_input, raw_logits) :\n \n #Get Template and Mask\n background = reshape_layer(background_dense(class_input))\n \n #Add Template and Multiply Mask\n image_logits = background_layer([raw_logits, background])\n \n #Compute Image (Sigmoids from logits)\n image = image_layer(image_logits)\n \n #Tile each image to sample from and create sample axis\n image_logits_upsampled = upsampling_layer(image_logits)\n sampled_image = sampling_layer(image_logits_upsampled)\n sampled_image = permute_layer(sampled_image)\n \n return image_logits, image, sampled_image\n \n return _sampler_func\n", "_____no_output_____" ], [ "#Scrambler network definition\n\ndef make_resblock(n_channels=64, window_size=8, dilation_rate=1, group_ix=0, layer_ix=0, drop_rate=0.0) :\n\n #Initialize res block layers\n batch_norm_0 = BatchNormalization(name='scrambler_resblock_' + str(group_ix) + '_' + str(layer_ix) + '_batch_norm_0')\n\n relu_0 = Lambda(lambda x: K.relu(x, alpha=0.0))\n\n conv_0 = Conv2D(n_channels, (window_size, window_size), dilation_rate=dilation_rate, strides=(1, 1), padding='same', activation='linear', kernel_initializer='glorot_normal', name='scrambler_resblock_' + str(group_ix) + '_' + str(layer_ix) + '_conv_0')\n\n batch_norm_1 = BatchNormalization(name='scrambler_resblock_' + str(group_ix) + '_' + str(layer_ix) + '_batch_norm_1')\n\n relu_1 = Lambda(lambda x: K.relu(x, alpha=0.0))\n\n conv_1 = Conv2D(n_channels, (window_size, window_size), dilation_rate=dilation_rate, strides=(1, 1), padding='same', activation='linear', kernel_initializer='glorot_normal', name='scrambler_resblock_' + str(group_ix) + '_' + str(layer_ix) + '_conv_1')\n\n skip_1 = Lambda(lambda x: x[0] + x[1], name='scrambler_resblock_' + str(group_ix) + '_' + str(layer_ix) + '_skip_1')\n\n drop_1 = None\n if drop_rate > 0.0 :\n drop_1 = Dropout(drop_rate)\n \n #Execute res block\n def _resblock_func(input_tensor) :\n batch_norm_0_out = batch_norm_0(input_tensor)\n relu_0_out = relu_0(batch_norm_0_out)\n conv_0_out = conv_0(relu_0_out)\n\n batch_norm_1_out = batch_norm_1(conv_0_out)\n relu_1_out = relu_1(batch_norm_1_out)\n \n if drop_rate > 0.0 :\n conv_1_out = drop_1(conv_1(relu_1_out))\n else :\n conv_1_out = conv_1(relu_1_out)\n\n skip_1_out = skip_1([conv_1_out, input_tensor])\n \n return skip_1_out\n\n return _resblock_func\n\ndef get_rand_lum(lum, x, min_lum=0.1, max_lum=0.5) :\n \n rand_lum = K.random_uniform(shape=K.shape(lum), minval=min_lum, maxval=max_lum)\n \n return K.switch(K.learning_phase(), rand_lum, lum)\n\ndef load_scrambler_network(n_groups=1, n_resblocks_per_group=4, n_channels=32, window_size=8, dilation_rates=[1], drop_rate=0.0, feature_min_lum=0.1, feature_max_lum=0.5) :\n\n #Discriminator network definition\n conv_0 = Conv2D(n_channels, (1, 1), strides=(1, 1), padding='same', activation='linear', kernel_initializer='glorot_normal', name='scrambler_conv_0')\n \n rand_lum = Lambda(lambda x: get_rand_lum(x[0], x[1], min_lum=feature_min_lum, max_lum=feature_max_lum))\n lum_concat = Lambda(lambda x: K.concatenate([x[0], K.tile(K.expand_dims(K.expand_dims(x[1], axis=1), axis=1), (1, K.shape(x[0])[1], K.shape(x[0])[2], 1))], axis=-1))\n \n skip_convs = []\n resblock_groups = []\n for group_ix in range(n_groups) :\n \n skip_convs.append(Conv2D(n_channels, (1, 1), strides=(1, 1), padding='same', activation='linear', kernel_initializer='glorot_normal', name='scrambler_skip_conv_' + str(group_ix)))\n \n resblocks = []\n for layer_ix in range(n_resblocks_per_group) :\n resblocks.append(make_resblock(n_channels=n_channels, window_size=window_size, dilation_rate=dilation_rates[group_ix], group_ix=group_ix, layer_ix=layer_ix, drop_rate=drop_rate))\n \n resblock_groups.append(resblocks)\n\n last_block_conv = Conv2D(n_channels, (1, 1), strides=(1, 1), padding='same', activation='linear', kernel_initializer='glorot_normal', name='scrambler_last_block_conv')\n \n skip_add = Lambda(lambda x: x[0] + x[1], name='scrambler_skip_add')\n \n final_conv = Conv2D(1, (1, 1), strides=(1, 1), padding='same', activation='softplus', kernel_initializer='glorot_normal', name='scrambler_final_conv')\n \n image_to_logits = Lambda(lambda x: 2. * x - 1., name='scrambler_image_to_logits')\n \n scale_logits = Lambda(lambda x: x[1] / K.maximum(x[0], K.epsilon()), name='scrambler_logit_scale')\n \n def _scrambler_func(image_input, lum_input) :\n \n rand_lum_out = rand_lum([lum_input, image_input])\n conv_0_out = conv_0(lum_concat([image_input, rand_lum_out]))\n\n #Connect group of res blocks\n output_tensor = conv_0_out\n\n #Res block group execution\n skip_conv_outs = []\n for group_ix in range(n_groups) :\n skip_conv_out = skip_convs[group_ix](output_tensor)\n skip_conv_outs.append(skip_conv_out)\n\n for layer_ix in range(n_resblocks_per_group) :\n output_tensor = resblock_groups[group_ix][layer_ix](output_tensor)\n \n #Last res block extr conv\n last_block_conv_out = last_block_conv(output_tensor)\n\n skip_add_out = last_block_conv_out\n for group_ix in range(n_groups) :\n skip_add_out = skip_add([skip_add_out, skip_conv_outs[group_ix]])\n\n #Final conv out\n final_conv_out = final_conv(skip_add_out)\n \n #Scale logits by importance scores\n scaled_logits = scale_logits([final_conv_out, image_to_logits(image_input)])\n \n return scaled_logits, final_conv_out, rand_lum_out\n\n return _scrambler_func\n", "_____no_output_____" ], [ "#Keras loss functions\n\ndef get_sigmoid_kl_divergence() :\n\n def _sigmoid_kl_divergence(y_true, y_pred) :\n\n y_pred = K.clip(y_pred, K.epsilon(), 1.0 - K.epsilon())\n y_true = K.clip(y_true, K.epsilon(), 1.0 - K.epsilon())\n \n mean_kl = K.mean(y_true * K.log(y_true / y_pred) + (1.0 - y_true) * K.log((1.0 - y_true) / (1.0 - y_pred)), axis=-1)\n \n return mean_kl\n \n return _sigmoid_kl_divergence\n\ndef get_margin_lum_ame() :\n \n def _margin_lum_ame(importance_scores, max_lum) :\n \n p_ons = 2. * K.sigmoid(importance_scores[..., 0]) - 1.\n \n mean_p_on = K.mean(p_ons, axis=(1, 2))\n\n margin_p_on = K.switch(mean_p_on > max_lum[:, 0], mean_p_on - max_lum[:, 0], K.zeros_like(mean_p_on))\n \n return margin_p_on\n \n return _margin_lum_ame\n\ndef get_target_lum_sme() :\n \n def _target_lum_sme(importance_scores, target_lum) :\n \n p_ons = 2. * K.sigmoid(importance_scores[..., 0]) - 1.\n \n mean_p_on = K.mean(p_ons, axis=(1, 2))\n \n return (mean_p_on - target_lum[:, 0])**2\n \n return _target_lum_sme\n\ndef get_weighted_loss(loss_coeff=1.) :\n \n def _min_pred(y_true, y_pred) :\n return loss_coeff * y_pred\n \n return _min_pred\n", "_____no_output_____" ], [ "#Initialize Encoder and Decoder networks\nbatch_size = 32\nn_rows = 28\nn_cols = 28\nn_samples = 32\n\n#Resnet parameters\nresnet_n_groups = 5\nresnet_n_resblocks_per_group = 4\nresnet_n_channels = 32\nresnet_window_size = 3\nresnet_dilation_rates = [1, 2, 4, 2, 1]\nresnet_drop_rate = 0.0\nresnet_feature_min_lum = 0.025\nresnet_feature_max_lum = 0.95\n\n#Load scrambler\nscrambler = load_scrambler_network(\n n_groups=resnet_n_groups,\n n_resblocks_per_group=resnet_n_resblocks_per_group,\n n_channels=resnet_n_channels, window_size=resnet_window_size,\n dilation_rates=resnet_dilation_rates,\n drop_rate=resnet_drop_rate,\n feature_min_lum=resnet_feature_min_lum,\n feature_max_lum=resnet_feature_max_lum\n)\n\n#Load sampler\nsampler = build_sampler(batch_size, n_rows, n_cols, n_classes=1, n_samples=n_samples)\n", "_____no_output_____" ], [ "#Load Predictor\npredictor_path = 'saved_models/mnist_binarized_cnn_digit_2_vs_4.h5'\n\npredictor = load_model(predictor_path)\n\npredictor.trainable = False\npredictor.compile(optimizer=keras.optimizers.SGD(lr=0.1), loss='mean_squared_error')\n", "_____no_output_____" ], [ "#Create inverted labels\n\ny_train_inv = 1. - y_train\ny_test_inv = 1. - y_test\n", "_____no_output_____" ], [ "#Build scrambler model\nscrambler_class = Input(shape=(1,), name='scrambler_class')\nscrambler_input = Input(shape=(n_rows, n_cols, 1), name='scrambler_input')\nscrambler_lum = Input(shape=(1,), name='scrambler_lum')\n\nscrambled_logits, importance_scores, _ = scrambler(scrambler_input, scrambler_lum)\n\nimage_logits, image, sampled_image = sampler(scrambler_class, scrambled_logits)\n\nscrambler_model = Model([scrambler_input, scrambler_class, scrambler_lum], [image_logits, image, sampled_image, importance_scores])\n\n#Initialize Templates and Masks\ninitialize_templates(scrambler_model, [x_mean_logits])\n\nscrambler_model.compile(\n optimizer=keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999),\n loss='mean_squared_error'\n)\n", "_____no_output_____" ], [ "#Build Auto-scrambler pipeline\n\n#Define model inputs\nae_scrambler_class = Input(shape=(1,), name='ae_scrambler_class')\nae_scrambler_input = Input(shape=(n_rows, n_cols, 1), name='ae_scrambler_input')\nae_scrambler_lum = Input(shape=(1,), name='ae_scrambler_lum')\nae_label_input = Input(shape=(1,), name='ae_label_input')\n\nscrambled_logits, importance_scores, target_lum = scrambler(ae_scrambler_input, ae_scrambler_lum)\n\n#Run encoder and decoder\n_, scrambled_image, scrambled_sample = sampler(ae_scrambler_class, scrambled_logits)\n\n#Define layer to deflate sample axis\ndeflate_scrambled_sample = Lambda(lambda x: K.reshape(x, (batch_size * n_samples, n_rows, n_cols, 1)), name='deflate_scrambled_sample')\n\n#Deflate sample axis\nscrambled_sample_deflated = deflate_scrambled_sample(scrambled_sample)\n\n#Make reference prediction on non-scrambled input sequence\ny_pred_non_scrambled_deflated = ae_label_input#predictor([ae_scrambler_input])\n\n#Make prediction on scrambled sequence samples\ny_pred_scrambled_deflated = predictor([scrambled_sample_deflated])\n\n#Define layer to inflate sample axis\ninflate_non_scrambled_prediction = Lambda(lambda x: K.tile(x, (1, n_samples)), name='inflate_non_scrambled_prediction')\ninflate_scrambled_prediction = Lambda(lambda x: K.reshape(x, (batch_size, n_samples)), name='inflate_scrambled_prediction')\n\n#Inflate sample axis\ny_pred_non_scrambled = inflate_non_scrambled_prediction(y_pred_non_scrambled_deflated)\ny_pred_scrambled = inflate_scrambled_prediction(y_pred_scrambled_deflated)\n\n#NLL cost\nnll_loss_func = get_sigmoid_kl_divergence()\n\n#Conservation cost\nconservation_loss_func = get_target_lum_sme()\n\n#Entropy cost\nentropy_loss_func = get_target_lum_sme()\n#entropy_loss_func = get_margin_lum_ame()\n\n#Define annealing coefficient\nanneal_coeff = K.variable(1.0)\n\n#Execute NLL cost\nnll_loss = Lambda(lambda x: nll_loss_func(x[0], x[1]), name='nll')([y_pred_non_scrambled, y_pred_scrambled])\n\n#Execute conservation cost\nconservation_loss = Lambda(lambda x: anneal_coeff * conservation_loss_func(x[0], x[1]), name='conservation')([importance_scores, target_lum])\n\n#Execute entropy cost\nentropy_loss = Lambda(lambda x: (1. - anneal_coeff) * entropy_loss_func(x[0], x[1]), name='entropy')([importance_scores, target_lum])\n\nloss_model = Model(\n [ae_scrambler_class, ae_scrambler_input, ae_scrambler_lum, ae_label_input],\n [nll_loss, conservation_loss, entropy_loss]\n)\n\n#Initialize Templates and Masks\ninitialize_templates(loss_model, [x_mean_logits])\n\nloss_model.compile(\n optimizer=keras.optimizers.Adam(lr=0.0001, beta_1=0.5, beta_2=0.9),\n loss={\n 'nll' : get_weighted_loss(loss_coeff=1.0),\n 'conservation' : get_weighted_loss(loss_coeff=1.0),\n 'entropy' : get_weighted_loss(loss_coeff=1200.0)\n }\n)\n", "_____no_output_____" ], [ "scrambler_model.summary()", "__________________________________________________________________________________________________\nLayer (type) Output Shape Param # Connected to \n==================================================================================================\nscrambler_input (InputLayer) (None, 28, 28, 1) 0 \n__________________________________________________________________________________________________\nscrambler_lum (InputLayer) (None, 1) 0 \n__________________________________________________________________________________________________\nlambda_1 (Lambda) (None, 1) 0 scrambler_lum[0][0] \n scrambler_input[0][0] \n__________________________________________________________________________________________________\nlambda_2 (Lambda) (None, 28, 28, 2) 0 scrambler_input[0][0] \n lambda_1[0][0] \n__________________________________________________________________________________________________\nscrambler_conv_0 (Conv2D) (None, 28, 28, 32) 96 lambda_2[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_0_batch_no (None, 28, 28, 32) 128 scrambler_conv_0[0][0] \n__________________________________________________________________________________________________\nlambda_3 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_0_conv_0 ( (None, 28, 28, 32) 9248 lambda_3[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_0_conv_0[0][\n__________________________________________________________________________________________________\nlambda_4 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_0_conv_1 ( (None, 28, 28, 32) 9248 lambda_4[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_0_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_0_0_conv_1[0][\n scrambler_conv_0[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_0_skip_1[0][\n__________________________________________________________________________________________________\nlambda_5 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_1_conv_0 ( (None, 28, 28, 32) 9248 lambda_5[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_1_conv_0[0][\n__________________________________________________________________________________________________\nlambda_6 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_1_conv_1 ( (None, 28, 28, 32) 9248 lambda_6[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_1_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_0_1_conv_1[0][\n scrambler_resblock_0_0_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_0_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_1_skip_1[0][\n__________________________________________________________________________________________________\nlambda_7 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_2_conv_0 ( (None, 28, 28, 32) 9248 lambda_7[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_2_conv_0[0][\n__________________________________________________________________________________________________\nlambda_8 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_2_conv_1 ( (None, 28, 28, 32) 9248 lambda_8[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_2_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_0_2_conv_1[0][\n scrambler_resblock_0_1_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_0_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_2_skip_1[0][\n__________________________________________________________________________________________________\nlambda_9 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_3_conv_0 ( (None, 28, 28, 32) 9248 lambda_9[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_3_conv_0[0][\n__________________________________________________________________________________________________\nlambda_10 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_3_conv_1 ( (None, 28, 28, 32) 9248 lambda_10[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_3_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_0_3_conv_1[0][\n scrambler_resblock_0_2_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_1_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_3_skip_1[0][\n__________________________________________________________________________________________________\nlambda_11 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_0_conv_0 ( (None, 28, 28, 32) 9248 lambda_11[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_0_conv_0[0][\n__________________________________________________________________________________________________\nlambda_12 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_0_conv_1 ( (None, 28, 28, 32) 9248 lambda_12[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_0_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_1_0_conv_1[0][\n scrambler_resblock_0_3_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_1_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_0_skip_1[0][\n__________________________________________________________________________________________________\nlambda_13 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_1_conv_0 ( (None, 28, 28, 32) 9248 lambda_13[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_1_conv_0[0][\n__________________________________________________________________________________________________\nlambda_14 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_1_conv_1 ( (None, 28, 28, 32) 9248 lambda_14[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_1_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_1_1_conv_1[0][\n scrambler_resblock_1_0_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_1_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_1_skip_1[0][\n__________________________________________________________________________________________________\nlambda_15 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_2_conv_0 ( (None, 28, 28, 32) 9248 lambda_15[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_2_conv_0[0][\n__________________________________________________________________________________________________\nlambda_16 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_2_conv_1 ( (None, 28, 28, 32) 9248 lambda_16[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_2_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_1_2_conv_1[0][\n scrambler_resblock_1_1_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_1_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_2_skip_1[0][\n__________________________________________________________________________________________________\nlambda_17 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_3_conv_0 ( (None, 28, 28, 32) 9248 lambda_17[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_3_conv_0[0][\n__________________________________________________________________________________________________\nlambda_18 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_3_conv_1 ( (None, 28, 28, 32) 9248 lambda_18[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_3_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_1_3_conv_1[0][\n scrambler_resblock_1_2_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_2_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_3_skip_1[0][\n__________________________________________________________________________________________________\nlambda_19 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_0_conv_0 ( (None, 28, 28, 32) 9248 lambda_19[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_0_conv_0[0][\n__________________________________________________________________________________________________\nlambda_20 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_0_conv_1 ( (None, 28, 28, 32) 9248 lambda_20[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_0_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_2_0_conv_1[0][\n scrambler_resblock_1_3_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_2_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_0_skip_1[0][\n__________________________________________________________________________________________________\nlambda_21 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_1_conv_0 ( (None, 28, 28, 32) 9248 lambda_21[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_1_conv_0[0][\n__________________________________________________________________________________________________\nlambda_22 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_1_conv_1 ( (None, 28, 28, 32) 9248 lambda_22[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_1_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_2_1_conv_1[0][\n scrambler_resblock_2_0_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_2_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_1_skip_1[0][\n__________________________________________________________________________________________________\nlambda_23 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_2_conv_0 ( (None, 28, 28, 32) 9248 lambda_23[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_2_conv_0[0][\n__________________________________________________________________________________________________\nlambda_24 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_2_conv_1 ( (None, 28, 28, 32) 9248 lambda_24[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_2_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_2_2_conv_1[0][\n scrambler_resblock_2_1_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_2_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_2_skip_1[0][\n__________________________________________________________________________________________________\nlambda_25 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_3_conv_0 ( (None, 28, 28, 32) 9248 lambda_25[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_3_conv_0[0][\n__________________________________________________________________________________________________\nlambda_26 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_3_conv_1 ( (None, 28, 28, 32) 9248 lambda_26[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_3_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_2_3_conv_1[0][\n scrambler_resblock_2_2_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_3_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_3_skip_1[0][\n__________________________________________________________________________________________________\nlambda_27 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_0_conv_0 ( (None, 28, 28, 32) 9248 lambda_27[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_0_conv_0[0][\n__________________________________________________________________________________________________\nlambda_28 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_0_conv_1 ( (None, 28, 28, 32) 9248 lambda_28[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_0_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_3_0_conv_1[0][\n scrambler_resblock_2_3_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_3_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_0_skip_1[0][\n__________________________________________________________________________________________________\nlambda_29 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_1_conv_0 ( (None, 28, 28, 32) 9248 lambda_29[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_1_conv_0[0][\n__________________________________________________________________________________________________\nlambda_30 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_1_conv_1 ( (None, 28, 28, 32) 9248 lambda_30[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_1_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_3_1_conv_1[0][\n scrambler_resblock_3_0_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_3_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_1_skip_1[0][\n__________________________________________________________________________________________________\nlambda_31 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_2_conv_0 ( (None, 28, 28, 32) 9248 lambda_31[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_2_conv_0[0][\n__________________________________________________________________________________________________\nlambda_32 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_2_conv_1 ( (None, 28, 28, 32) 9248 lambda_32[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_2_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_3_2_conv_1[0][\n scrambler_resblock_3_1_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_3_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_2_skip_1[0][\n__________________________________________________________________________________________________\nlambda_33 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_3_conv_0 ( (None, 28, 28, 32) 9248 lambda_33[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_3_conv_0[0][\n__________________________________________________________________________________________________\nlambda_34 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_3_conv_1 ( (None, 28, 28, 32) 9248 lambda_34[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_3_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_3_3_conv_1[0][\n scrambler_resblock_3_2_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_4_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_3_skip_1[0][\n__________________________________________________________________________________________________\nlambda_35 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_0_conv_0 ( (None, 28, 28, 32) 9248 lambda_35[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_0_conv_0[0][\n__________________________________________________________________________________________________\nlambda_36 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_0_conv_1 ( (None, 28, 28, 32) 9248 lambda_36[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_0_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_4_0_conv_1[0][\n scrambler_resblock_3_3_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_4_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_0_skip_1[0][\n__________________________________________________________________________________________________\nlambda_37 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_1_conv_0 ( (None, 28, 28, 32) 9248 lambda_37[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_1_conv_0[0][\n__________________________________________________________________________________________________\nlambda_38 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_1_conv_1 ( (None, 28, 28, 32) 9248 lambda_38[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_1_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_4_1_conv_1[0][\n scrambler_resblock_4_0_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_4_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_1_skip_1[0][\n__________________________________________________________________________________________________\nlambda_39 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_2_conv_0 ( (None, 28, 28, 32) 9248 lambda_39[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_2_conv_0[0][\n__________________________________________________________________________________________________\nlambda_40 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_2_conv_1 ( (None, 28, 28, 32) 9248 lambda_40[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_2_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_4_2_conv_1[0][\n scrambler_resblock_4_1_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_resblock_4_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_2_skip_1[0][\n__________________________________________________________________________________________________\nlambda_41 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_3_conv_0 ( (None, 28, 28, 32) 9248 lambda_41[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_3_conv_0[0][\n__________________________________________________________________________________________________\nlambda_42 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_3_conv_1 ( (None, 28, 28, 32) 9248 lambda_42[0][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_3_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_4_3_conv_1[0][\n scrambler_resblock_4_2_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_last_block_conv (Conv (None, 28, 28, 32) 1056 scrambler_resblock_4_3_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_skip_conv_0 (Conv2D) (None, 28, 28, 32) 1056 scrambler_conv_0[0][0] \n__________________________________________________________________________________________________\nscrambler_skip_add (Lambda) (None, 28, 28, 32) 0 scrambler_last_block_conv[0][0] \n scrambler_skip_conv_0[0][0] \n scrambler_skip_add[0][0] \n scrambler_skip_conv_1[0][0] \n scrambler_skip_add[1][0] \n scrambler_skip_conv_2[0][0] \n scrambler_skip_add[2][0] \n scrambler_skip_conv_3[0][0] \n scrambler_skip_add[3][0] \n scrambler_skip_conv_4[0][0] \n__________________________________________________________________________________________________\nscrambler_skip_conv_1 (Conv2D) (None, 28, 28, 32) 1056 scrambler_resblock_0_3_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_skip_conv_2 (Conv2D) (None, 28, 28, 32) 1056 scrambler_resblock_1_3_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_skip_conv_3 (Conv2D) (None, 28, 28, 32) 1056 scrambler_resblock_2_3_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_skip_conv_4 (Conv2D) (None, 28, 28, 32) 1056 scrambler_resblock_3_3_skip_1[0][\n__________________________________________________________________________________________________\nscrambler_class (InputLayer) (None, 1) 0 \n__________________________________________________________________________________________________\nscrambler_final_conv (Conv2D) (None, 28, 28, 1) 33 scrambler_skip_add[4][0] \n__________________________________________________________________________________________________\nscrambler_image_to_logits (Lamb (None, 28, 28, 1) 0 scrambler_input[0][0] \n__________________________________________________________________________________________________\nbackground_dense (Embedding) (None, 1, 784) 784 scrambler_class[0][0] \n__________________________________________________________________________________________________\nscrambler_logit_scale (Lambda) (None, 28, 28, 1) 0 scrambler_final_conv[0][0] \n scrambler_image_to_logits[0][0] \n__________________________________________________________________________________________________\nreshape_1 (Reshape) (None, 28, 28, 1) 0 background_dense[0][0] \n__________________________________________________________________________________________________\nbackground_layer (Lambda) (None, 28, 28, 1) 0 scrambler_logit_scale[0][0] \n reshape_1[0][0] \n__________________________________________________________________________________________________\nupsampling_layer (Lambda) (None, 28, 28, 1) 0 background_layer[0][0] \n__________________________________________________________________________________________________\nimage_sampler (Lambda) (None, 28, 28, 1) 0 upsampling_layer[0][0] \n__________________________________________________________________________________________________\nimage (Lambda) (None, 28, 28, 1) 0 background_layer[0][0] \n__________________________________________________________________________________________________\npermute_layer (Lambda) (32, 32, 28, 28, 1) 0 image_sampler[0][0] \n==================================================================================================\nTotal params: 382,289\nTrainable params: 378,945\nNon-trainable params: 3,344\n__________________________________________________________________________________________________\n" ], [ "loss_model.summary()", "__________________________________________________________________________________________________\nLayer (type) Output Shape Param # Connected to \n==================================================================================================\nae_scrambler_input (InputLayer) (None, 28, 28, 1) 0 \n__________________________________________________________________________________________________\nae_scrambler_lum (InputLayer) (None, 1) 0 \n__________________________________________________________________________________________________\nlambda_1 (Lambda) (None, 1) 0 ae_scrambler_lum[0][0] \n ae_scrambler_input[0][0] \n__________________________________________________________________________________________________\nlambda_2 (Lambda) (None, 28, 28, 2) 0 ae_scrambler_input[0][0] \n lambda_1[1][0] \n__________________________________________________________________________________________________\nscrambler_conv_0 (Conv2D) (None, 28, 28, 32) 96 lambda_2[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_0_batch_no (None, 28, 28, 32) 128 scrambler_conv_0[1][0] \n__________________________________________________________________________________________________\nlambda_3 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_0_conv_0 ( (None, 28, 28, 32) 9248 lambda_3[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_0_conv_0[1][\n__________________________________________________________________________________________________\nlambda_4 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_0_conv_1 ( (None, 28, 28, 32) 9248 lambda_4[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_0_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_0_0_conv_1[1][\n scrambler_conv_0[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_0_skip_1[1][\n__________________________________________________________________________________________________\nlambda_5 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_1_conv_0 ( (None, 28, 28, 32) 9248 lambda_5[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_1_conv_0[1][\n__________________________________________________________________________________________________\nlambda_6 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_1_conv_1 ( (None, 28, 28, 32) 9248 lambda_6[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_1_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_0_1_conv_1[1][\n scrambler_resblock_0_0_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_0_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_1_skip_1[1][\n__________________________________________________________________________________________________\nlambda_7 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_2_conv_0 ( (None, 28, 28, 32) 9248 lambda_7[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_2_conv_0[1][\n__________________________________________________________________________________________________\nlambda_8 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_2_conv_1 ( (None, 28, 28, 32) 9248 lambda_8[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_2_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_0_2_conv_1[1][\n scrambler_resblock_0_1_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_0_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_2_skip_1[1][\n__________________________________________________________________________________________________\nlambda_9 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_3_conv_0 ( (None, 28, 28, 32) 9248 lambda_9[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_3_conv_0[1][\n__________________________________________________________________________________________________\nlambda_10 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_0_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_0_3_conv_1 ( (None, 28, 28, 32) 9248 lambda_10[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_0_3_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_0_3_conv_1[1][\n scrambler_resblock_0_2_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_1_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_0_3_skip_1[1][\n__________________________________________________________________________________________________\nlambda_11 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_0_conv_0 ( (None, 28, 28, 32) 9248 lambda_11[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_0_conv_0[1][\n__________________________________________________________________________________________________\nlambda_12 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_0_conv_1 ( (None, 28, 28, 32) 9248 lambda_12[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_0_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_1_0_conv_1[1][\n scrambler_resblock_0_3_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_1_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_0_skip_1[1][\n__________________________________________________________________________________________________\nlambda_13 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_1_conv_0 ( (None, 28, 28, 32) 9248 lambda_13[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_1_conv_0[1][\n__________________________________________________________________________________________________\nlambda_14 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_1_conv_1 ( (None, 28, 28, 32) 9248 lambda_14[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_1_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_1_1_conv_1[1][\n scrambler_resblock_1_0_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_1_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_1_skip_1[1][\n__________________________________________________________________________________________________\nlambda_15 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_2_conv_0 ( (None, 28, 28, 32) 9248 lambda_15[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_2_conv_0[1][\n__________________________________________________________________________________________________\nlambda_16 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_2_conv_1 ( (None, 28, 28, 32) 9248 lambda_16[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_2_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_1_2_conv_1[1][\n scrambler_resblock_1_1_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_1_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_2_skip_1[1][\n__________________________________________________________________________________________________\nlambda_17 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_3_conv_0 ( (None, 28, 28, 32) 9248 lambda_17[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_3_conv_0[1][\n__________________________________________________________________________________________________\nlambda_18 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_1_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_1_3_conv_1 ( (None, 28, 28, 32) 9248 lambda_18[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_1_3_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_1_3_conv_1[1][\n scrambler_resblock_1_2_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_2_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_1_3_skip_1[1][\n__________________________________________________________________________________________________\nlambda_19 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_0_conv_0 ( (None, 28, 28, 32) 9248 lambda_19[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_0_conv_0[1][\n__________________________________________________________________________________________________\nlambda_20 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_0_conv_1 ( (None, 28, 28, 32) 9248 lambda_20[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_0_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_2_0_conv_1[1][\n scrambler_resblock_1_3_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_2_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_0_skip_1[1][\n__________________________________________________________________________________________________\nlambda_21 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_1_conv_0 ( (None, 28, 28, 32) 9248 lambda_21[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_1_conv_0[1][\n__________________________________________________________________________________________________\nlambda_22 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_1_conv_1 ( (None, 28, 28, 32) 9248 lambda_22[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_1_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_2_1_conv_1[1][\n scrambler_resblock_2_0_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_2_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_1_skip_1[1][\n__________________________________________________________________________________________________\nlambda_23 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_2_conv_0 ( (None, 28, 28, 32) 9248 lambda_23[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_2_conv_0[1][\n__________________________________________________________________________________________________\nlambda_24 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_2_conv_1 ( (None, 28, 28, 32) 9248 lambda_24[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_2_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_2_2_conv_1[1][\n scrambler_resblock_2_1_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_2_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_2_skip_1[1][\n__________________________________________________________________________________________________\nlambda_25 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_3_conv_0 ( (None, 28, 28, 32) 9248 lambda_25[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_3_conv_0[1][\n__________________________________________________________________________________________________\nlambda_26 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_2_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_2_3_conv_1 ( (None, 28, 28, 32) 9248 lambda_26[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_2_3_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_2_3_conv_1[1][\n scrambler_resblock_2_2_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_3_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_2_3_skip_1[1][\n__________________________________________________________________________________________________\nlambda_27 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_0_conv_0 ( (None, 28, 28, 32) 9248 lambda_27[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_0_conv_0[1][\n__________________________________________________________________________________________________\nlambda_28 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_0_conv_1 ( (None, 28, 28, 32) 9248 lambda_28[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_0_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_3_0_conv_1[1][\n scrambler_resblock_2_3_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_3_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_0_skip_1[1][\n__________________________________________________________________________________________________\nlambda_29 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_1_conv_0 ( (None, 28, 28, 32) 9248 lambda_29[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_1_conv_0[1][\n__________________________________________________________________________________________________\nlambda_30 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_1_conv_1 ( (None, 28, 28, 32) 9248 lambda_30[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_1_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_3_1_conv_1[1][\n scrambler_resblock_3_0_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_3_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_1_skip_1[1][\n__________________________________________________________________________________________________\nlambda_31 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_2_conv_0 ( (None, 28, 28, 32) 9248 lambda_31[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_2_conv_0[1][\n__________________________________________________________________________________________________\nlambda_32 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_2_conv_1 ( (None, 28, 28, 32) 9248 lambda_32[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_2_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_3_2_conv_1[1][\n scrambler_resblock_3_1_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_3_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_2_skip_1[1][\n__________________________________________________________________________________________________\nlambda_33 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_3_conv_0 ( (None, 28, 28, 32) 9248 lambda_33[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_3_conv_0[1][\n__________________________________________________________________________________________________\nlambda_34 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_3_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_3_3_conv_1 ( (None, 28, 28, 32) 9248 lambda_34[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_3_3_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_3_3_conv_1[1][\n scrambler_resblock_3_2_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_4_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_3_3_skip_1[1][\n__________________________________________________________________________________________________\nlambda_35 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_0_conv_0 ( (None, 28, 28, 32) 9248 lambda_35[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_0_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_0_conv_0[1][\n__________________________________________________________________________________________________\nlambda_36 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_0_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_0_conv_1 ( (None, 28, 28, 32) 9248 lambda_36[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_0_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_4_0_conv_1[1][\n scrambler_resblock_3_3_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_4_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_0_skip_1[1][\n__________________________________________________________________________________________________\nlambda_37 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_1_conv_0 ( (None, 28, 28, 32) 9248 lambda_37[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_1_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_1_conv_0[1][\n__________________________________________________________________________________________________\nlambda_38 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_1_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_1_conv_1 ( (None, 28, 28, 32) 9248 lambda_38[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_1_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_4_1_conv_1[1][\n scrambler_resblock_4_0_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_4_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_1_skip_1[1][\n__________________________________________________________________________________________________\nlambda_39 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_2_conv_0 ( (None, 28, 28, 32) 9248 lambda_39[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_2_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_2_conv_0[1][\n__________________________________________________________________________________________________\nlambda_40 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_2_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_2_conv_1 ( (None, 28, 28, 32) 9248 lambda_40[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_2_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_4_2_conv_1[1][\n scrambler_resblock_4_1_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_resblock_4_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_2_skip_1[1][\n__________________________________________________________________________________________________\nlambda_41 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_3_conv_0 ( (None, 28, 28, 32) 9248 lambda_41[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_3_batch_no (None, 28, 28, 32) 128 scrambler_resblock_4_3_conv_0[1][\n__________________________________________________________________________________________________\nlambda_42 (Lambda) (None, 28, 28, 32) 0 scrambler_resblock_4_3_batch_norm\n__________________________________________________________________________________________________\nscrambler_resblock_4_3_conv_1 ( (None, 28, 28, 32) 9248 lambda_42[1][0] \n__________________________________________________________________________________________________\nscrambler_resblock_4_3_skip_1 ( (None, 28, 28, 32) 0 scrambler_resblock_4_3_conv_1[1][\n scrambler_resblock_4_2_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_last_block_conv (Conv (None, 28, 28, 32) 1056 scrambler_resblock_4_3_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_skip_conv_0 (Conv2D) (None, 28, 28, 32) 1056 scrambler_conv_0[1][0] \n__________________________________________________________________________________________________\nscrambler_skip_add (Lambda) (None, 28, 28, 32) 0 scrambler_last_block_conv[1][0] \n scrambler_skip_conv_0[1][0] \n scrambler_skip_add[5][0] \n scrambler_skip_conv_1[1][0] \n scrambler_skip_add[6][0] \n scrambler_skip_conv_2[1][0] \n scrambler_skip_add[7][0] \n scrambler_skip_conv_3[1][0] \n scrambler_skip_add[8][0] \n scrambler_skip_conv_4[1][0] \n__________________________________________________________________________________________________\nscrambler_skip_conv_1 (Conv2D) (None, 28, 28, 32) 1056 scrambler_resblock_0_3_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_skip_conv_2 (Conv2D) (None, 28, 28, 32) 1056 scrambler_resblock_1_3_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_skip_conv_3 (Conv2D) (None, 28, 28, 32) 1056 scrambler_resblock_2_3_skip_1[1][\n__________________________________________________________________________________________________\nscrambler_skip_conv_4 (Conv2D) (None, 28, 28, 32) 1056 scrambler_resblock_3_3_skip_1[1][\n__________________________________________________________________________________________________\nae_scrambler_class (InputLayer) (None, 1) 0 \n__________________________________________________________________________________________________\nscrambler_final_conv (Conv2D) (None, 28, 28, 1) 33 scrambler_skip_add[9][0] \n__________________________________________________________________________________________________\nscrambler_image_to_logits (Lamb (None, 28, 28, 1) 0 ae_scrambler_input[0][0] \n__________________________________________________________________________________________________\nbackground_dense (Embedding) (None, 1, 784) 784 ae_scrambler_class[0][0] \n__________________________________________________________________________________________________\nscrambler_logit_scale (Lambda) (None, 28, 28, 1) 0 scrambler_final_conv[1][0] \n scrambler_image_to_logits[1][0] \n__________________________________________________________________________________________________\nreshape_1 (Reshape) (None, 28, 28, 1) 0 background_dense[1][0] \n__________________________________________________________________________________________________\nbackground_layer (Lambda) (None, 28, 28, 1) 0 scrambler_logit_scale[1][0] \n reshape_1[1][0] \n__________________________________________________________________________________________________\nupsampling_layer (Lambda) (None, 28, 28, 1) 0 background_layer[1][0] \n__________________________________________________________________________________________________\nimage_sampler (Lambda) (None, 28, 28, 1) 0 upsampling_layer[1][0] \n__________________________________________________________________________________________________\npermute_layer (Lambda) (32, 32, 28, 28, 1) 0 image_sampler[1][0] \n__________________________________________________________________________________________________\ndeflate_scrambled_sample (Lambd (1024, 28, 28, 1) 0 permute_layer[1][0] \n__________________________________________________________________________________________________\nae_label_input (InputLayer) (None, 1) 0 \n__________________________________________________________________________________________________\nsequential_1 (Sequential) multiple 608769 deflate_scrambled_sample[0][0] \n__________________________________________________________________________________________________\ninflate_non_scrambled_predictio (None, 32) 0 ae_label_input[0][0] \n__________________________________________________________________________________________________\ninflate_scrambled_prediction (L (32, 32) 0 sequential_1[1][0] \n__________________________________________________________________________________________________\nnll (Lambda) (32,) 0 inflate_non_scrambled_prediction[\n inflate_scrambled_prediction[0][0\n__________________________________________________________________________________________________\nconservation (Lambda) (None,) 0 scrambler_final_conv[1][0] \n lambda_1[1][0] \n__________________________________________________________________________________________________\nentropy (Lambda) (None,) 0 scrambler_final_conv[1][0] \n lambda_1[1][0] \n==================================================================================================\nTotal params: 991,058\nTrainable params: 378,945\nNon-trainable params: 612,113\n__________________________________________________________________________________________________\n" ], [ "#Training configuration\n\n#Define number of training epochs\nn_epochs = 50\n\n#Define experiment suffix (optional)\nexperiment_suffix = \"_kl_divergence_var_lum_higher_entropy_penalty\"\n\n#Define anneal function\ndef _anneal_func(val, epoch, n_epochs=n_epochs) :\n if epoch in [0] :\n return 1.0\n \n return 0.0\n\narchitecture_str = \"resnet_\" + str(resnet_n_groups) + \"_\" + str(resnet_n_resblocks_per_group) + \"_\" + str(resnet_n_channels) + \"_\" + str(resnet_window_size) + \"_\" + str(resnet_drop_rate).replace(\".\", \"\")\n\nmodel_name = \"autoscrambler_dataset_\" + dataset_name + \"_inverted_scores_n_samples_\" + str(n_samples) + \"_\" + architecture_str + \"_n_epochs_\" + str(n_epochs) + experiment_suffix\n\nprint(\"Model save name = \" + model_name)\n", "Model save name = autoscrambler_dataset_mnist_2_vs_4_binary_predictor_inverted_scores_n_samples_32_resnet_5_4_32_3_00_n_epochs_50_kl_divergence_var_lum_higher_entropy_penalty\n" ], [ "#Execute training procedure\n\ncallbacks =[\n #ModelCheckpoint(\"model_checkpoints/\" + model_name + \"_epoch_{epoch:02d}.hdf5\", monitor='val_loss', mode='min', period=10, save_weights_only=True),\n EpochVariableCallback(anneal_coeff, _anneal_func)\n]\n\ns_train = np.zeros((x_train.shape[0], 1))\ns_test = np.zeros((x_test.shape[0], 1))\n\nlum_train = np.ones((x_train.shape[0], 1)) * 0.05\nlum_test = np.ones((x_test.shape[0], 1)) * 0.05\n\n# train the autoencoder\ntrain_history = loss_model.fit(\n [s_train, x_train, lum_train, y_train_inv],\n [s_train, s_train, s_train],\n shuffle=True,\n epochs=n_epochs,\n batch_size=batch_size,\n validation_data=(\n [s_test, x_test, lum_test, y_test_inv],\n [s_test, s_test, s_test]\n ),\n callbacks=callbacks\n)\n", "Train on 11776 samples, validate on 1984 samples\nEpoch 1/50\n11776/11776 [==============================] - 100s 8ms/step - loss: 2.3949 - nll_loss: 2.3567 - conservation_loss: 0.0383 - entropy_loss: 0.0000e+00 - val_loss: 1.8781 - val_nll_loss: 1.7650 - val_conservation_loss: 0.1131 - val_entropy_loss: 0.0000e+00\nEpoch 2/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 5.7371 - nll_loss: 2.7241 - conservation_loss: 0.0000e+00 - entropy_loss: 3.0130 - val_loss: 9.1147 - val_nll_loss: 8.5319 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.5828\nEpoch 3/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 4.3434 - nll_loss: 2.4682 - conservation_loss: 0.0000e+00 - entropy_loss: 1.8751 - val_loss: 8.1056 - val_nll_loss: 7.5064 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.5992\nEpoch 4/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 3.5382 - nll_loss: 2.0685 - conservation_loss: 0.0000e+00 - entropy_loss: 1.4697 - val_loss: 7.4120 - val_nll_loss: 5.9190 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 1.4931\nEpoch 5/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 3.4453 - nll_loss: 1.8984 - conservation_loss: 0.0000e+00 - entropy_loss: 1.5468 - val_loss: 7.2667 - val_nll_loss: 4.9890 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 2.2777\nEpoch 6/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 3.1345 - nll_loss: 1.8109 - conservation_loss: 0.0000e+00 - entropy_loss: 1.3237 - val_loss: 7.5711 - val_nll_loss: 7.0132 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.5579\nEpoch 7/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.9152 - nll_loss: 1.7046 - conservation_loss: 0.0000e+00 - entropy_loss: 1.2106 - val_loss: 6.6753 - val_nll_loss: 5.9665 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.7088\nEpoch 8/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.7632 - nll_loss: 1.6211 - conservation_loss: 0.0000e+00 - entropy_loss: 1.1421 - val_loss: 6.5547 - val_nll_loss: 4.9803 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 1.5745\nEpoch 9/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.7079 - nll_loss: 1.5491 - conservation_loss: 0.0000e+00 - entropy_loss: 1.1588 - val_loss: 6.3006 - val_nll_loss: 4.5752 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 1.7254\nEpoch 10/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.5664 - nll_loss: 1.4745 - conservation_loss: 0.0000e+00 - entropy_loss: 1.0919 - val_loss: 9.2609 - val_nll_loss: 9.0042 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.2567\nEpoch 11/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.4139 - nll_loss: 1.4451 - conservation_loss: 0.0000e+00 - entropy_loss: 0.9688 - val_loss: 5.9669 - val_nll_loss: 4.4266 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 1.5403\nEpoch 12/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.4371 - nll_loss: 1.3859 - conservation_loss: 0.0000e+00 - entropy_loss: 1.0512 - val_loss: 7.1698 - val_nll_loss: 6.9750 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.1947\nEpoch 13/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.4252 - nll_loss: 1.3519 - conservation_loss: 0.0000e+00 - entropy_loss: 1.0733 - val_loss: 5.6539 - val_nll_loss: 4.6225 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 1.0314\nEpoch 14/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.3000 - nll_loss: 1.2933 - conservation_loss: 0.0000e+00 - entropy_loss: 1.0067 - val_loss: 5.9034 - val_nll_loss: 3.6711 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 2.2323\nEpoch 15/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.1875 - nll_loss: 1.2361 - conservation_loss: 0.0000e+00 - entropy_loss: 0.9514 - val_loss: 5.5643 - val_nll_loss: 3.8309 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 1.7333\nEpoch 16/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.1893 - nll_loss: 1.2113 - conservation_loss: 0.0000e+00 - entropy_loss: 0.9780 - val_loss: 5.4836 - val_nll_loss: 4.3270 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 1.1566\nEpoch 17/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.2861 - nll_loss: 1.1888 - conservation_loss: 0.0000e+00 - entropy_loss: 1.0974 - val_loss: 5.5414 - val_nll_loss: 3.9561 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 1.5853\nEpoch 18/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.2348 - nll_loss: 1.1701 - conservation_loss: 0.0000e+00 - entropy_loss: 1.0647 - val_loss: 5.5860 - val_nll_loss: 5.1245 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.4614\nEpoch 19/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.0619 - nll_loss: 1.1332 - conservation_loss: 0.0000e+00 - entropy_loss: 0.9287 - val_loss: 5.3367 - val_nll_loss: 4.2434 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 1.0933\nEpoch 20/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.9318 - nll_loss: 1.0949 - conservation_loss: 0.0000e+00 - entropy_loss: 0.8369 - val_loss: 5.8792 - val_nll_loss: 5.6956 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.1837\nEpoch 21/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 2.0217 - nll_loss: 1.0562 - conservation_loss: 0.0000e+00 - entropy_loss: 0.9655 - val_loss: 5.0723 - val_nll_loss: 4.3117 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.7606\nEpoch 22/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.9114 - nll_loss: 1.0069 - conservation_loss: 0.0000e+00 - entropy_loss: 0.9045 - val_loss: 4.9424 - val_nll_loss: 4.0481 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.8942\nEpoch 23/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.8954 - nll_loss: 0.9874 - conservation_loss: 0.0000e+00 - entropy_loss: 0.9080 - val_loss: 4.8619 - val_nll_loss: 4.0795 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.7824\nEpoch 24/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.9802 - nll_loss: 0.9678 - conservation_loss: 0.0000e+00 - entropy_loss: 1.0124 - val_loss: 5.1990 - val_nll_loss: 4.1783 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 1.0207\nEpoch 25/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.8579 - nll_loss: 0.9292 - conservation_loss: 0.0000e+00 - entropy_loss: 0.9287 - val_loss: 4.9452 - val_nll_loss: 4.3863 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.5589\nEpoch 26/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.8917 - nll_loss: 0.9175 - conservation_loss: 0.0000e+00 - entropy_loss: 0.9741 - val_loss: 5.6314 - val_nll_loss: 2.4068 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 3.2246\nEpoch 27/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.9507 - nll_loss: 0.8728 - conservation_loss: 0.0000e+00 - entropy_loss: 1.0779 - val_loss: 4.8202 - val_nll_loss: 4.0396 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.7806\nEpoch 28/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.6793 - nll_loss: 0.8690 - conservation_loss: 0.0000e+00 - entropy_loss: 0.8102 - val_loss: 5.0866 - val_nll_loss: 3.0103 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 2.0762\nEpoch 29/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.7473 - nll_loss: 0.8274 - conservation_loss: 0.0000e+00 - entropy_loss: 0.9198 - val_loss: 4.5506 - val_nll_loss: 3.5554 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.9952\nEpoch 30/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.6530 - nll_loss: 0.8083 - conservation_loss: 0.0000e+00 - entropy_loss: 0.8447 - val_loss: 4.4216 - val_nll_loss: 3.7320 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 0.6896\nEpoch 31/50\n11776/11776 [==============================] - 84s 7ms/step - loss: 1.6820 - nll_loss: 0.8190 - conservation_loss: 0.0000e+00 - entropy_loss: 0.8630 - val_loss: 4.9226 - val_nll_loss: 2.4642 - val_conservation_loss: 0.0000e+00 - val_entropy_loss: 2.4584\n" ], [ "\nf, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(3 * 4, 3))\n\nn_epochs_actual = len(train_history.history['nll_loss'])\n\nax1.plot(np.arange(1, n_epochs_actual + 1), train_history.history['nll_loss'], linewidth=3, color='green')\nax1.plot(np.arange(1, n_epochs_actual + 1), train_history.history['val_nll_loss'], linewidth=3, color='orange')\n\nplt.sca(ax1)\nplt.xlabel(\"Epochs\", fontsize=14)\nplt.ylabel(\"NLL\", fontsize=14)\nplt.xlim(1, n_epochs_actual)\nplt.xticks([1, n_epochs_actual], [1, n_epochs_actual], fontsize=12)\nplt.yticks(fontsize=12)\n\nax2.plot(np.arange(1, n_epochs_actual + 1), train_history.history['entropy_loss'], linewidth=3, color='green')\nax2.plot(np.arange(1, n_epochs_actual + 1), train_history.history['val_entropy_loss'], linewidth=3, color='orange')\n\nplt.sca(ax2)\nplt.xlabel(\"Epochs\", fontsize=14)\nplt.ylabel(\"Entropy Loss\", fontsize=14)\nplt.xlim(1, n_epochs_actual)\nplt.xticks([1, n_epochs_actual], [1, n_epochs_actual], fontsize=12)\nplt.yticks(fontsize=12)\n\nax3.plot(np.arange(1, n_epochs_actual + 1), train_history.history['conservation_loss'], linewidth=3, color='green')\nax3.plot(np.arange(1, n_epochs_actual + 1), train_history.history['val_conservation_loss'], linewidth=3, color='orange')\n\nplt.sca(ax3)\nplt.xlabel(\"Epochs\", fontsize=14)\nplt.ylabel(\"Conservation Loss\", fontsize=14)\nplt.xlim(1, n_epochs_actual)\nplt.xticks([1, n_epochs_actual], [1, n_epochs_actual], fontsize=12)\nplt.yticks(fontsize=12)\n\nplt.tight_layout()\n\nplt.show()\n", "_____no_output_____" ], [ "# Save model and weights\nsave_dir = 'saved_models'\n\nif not os.path.isdir(save_dir):\n os.makedirs(save_dir)\n\nmodel_path = os.path.join(save_dir, model_name + '.h5')\n\nscrambler_model.save(model_path)\nprint('Saved scrambler model at %s ' % (model_path))\n", "Saved scrambler model at saved_models/autoscrambler_dataset_mnist_2_vs_4_binary_predictor_inverted_scores_n_samples_32_resnet_5_4_32_3_00_n_epochs_50_kl_divergence_var_lum_higher_entropy_penalty.h5 \n" ], [ "#Load models\nsave_dir = 'saved_models'\n\nif not os.path.isdir(save_dir):\n os.makedirs(save_dir)\n\nmodel_path = os.path.join(save_dir, model_name + '.h5')\nscrambler_model = load_model(model_path, custom_objects={\n 'bernoulli_sample' : bernoulli_sample,\n 'tf' : tf,\n 'get_rand_lum' : get_rand_lum\n})\n\nprint('Loaded scrambler model %s ' % (model_path))\n", "Loaded scrambler model saved_models/autoscrambler_dataset_mnist_2_vs_4_binary_predictor_inverted_scores_n_samples_32_resnet_5_4_32_3_00_n_epochs_50_kl_divergence_var_lum_higher_entropy_penalty.h5 \n" ], [ "#Visualize a few reconstructed images\n\nfrom numpy.ma import masked_array\n\ns_test = np.zeros((x_test.shape[0], 1))\n\nlum_test = np.ones((x_test.shape[0], 1)) * 0.05\n\n_, image_test, sample_test, importance_scores_test = scrambler_model.predict_on_batch(x=[x_test[:32], s_test[:32], lum_test[:32]])\n\nfor plot_i in range(0, 20) :\n \n print(\"Test image \" + str(plot_i) + \":\")\n \n y_test_hat_ref = predictor.predict(x=[np.expand_dims(x_test[plot_i], axis=0)], batch_size=1)[0, 0]\n y_test_hat = predictor.predict(x=[sample_test[plot_i]], batch_size=32)[:10, 0].tolist()\n \n print(\" - Prediction (original) = \" + str(round(y_test_hat_ref, 2))[:4])\n print(\" - Predictions (scrambled) = \" + str([float(str(round(y_test_hat[i], 2))[:4]) for i in range(len(y_test_hat))]))\n \n f, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(3 * 4, 3))\n\n ax1.imshow(x_test[plot_i, :, :, 0], cmap=\"Greys\", vmin=0.0, vmax=1.0, aspect='equal')\n\n plt.sca(ax1)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax2.imshow(image_test[plot_i, :, :, 0], cmap=\"Greys\", vmin=0.0, vmax=1.0, aspect='equal')\n\n plt.sca(ax2)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax3.imshow(importance_scores_test[plot_i, :, :, 0], cmap=\"hot\", vmin=0.0, vmax=np.max(importance_scores_test[plot_i, :, :, 0]), aspect='equal')\n\n plt.sca(ax3)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax4.imshow(x_test[plot_i, :, :, 0], cmap=\"Greys\", vmin=0.0, vmax=1.0, aspect='equal')\n\n plt.sca(ax4)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax4.imshow(importance_scores_test[plot_i, :, :, 0], alpha=0.75, cmap=\"hot\", vmin=0.0, vmax=np.max(importance_scores_test[plot_i, :, :, 0]), aspect='equal')\n\n plt.sca(ax4)\n plt.xticks([], [])\n plt.yticks([], [])\n\n plt.tight_layout()\n plt.show()\n", "Test image 0:\n - Prediction (original) = 0.0\n - Predictions (scrambled) = [0.7, 0.84, 0.42, 0.02, 0.02, 0.0, 0.12, 0.03, 0.06, 0.56]\n" ], [ "#Predict on test set\n\nsave_figs = True\n\ntest_ix = 0\n\nn_levels = 4\n\nimportance_thresh_qt = 0.0\n\nmin_importance_thresh = 10.\n\nlum_levels = [\n 0.05,\n 0.25,\n 0.45,\n 0.75\n]\n\nprint(\"Test image \" + str(test_ix) + \":\")\n \ny_test_hat_ref = predictor.predict(x=[np.expand_dims(x_test[test_ix], axis=0)], batch_size=1)[0, 0]\n\nprint(\" - Prediction (original) = \" + str(round(y_test_hat_ref, 2))[:4])\n\nimportance_scores_levels = []\ny_test_hat_levels = []\n\nfor level_ix in range(n_levels) :\n \n print(\"Depth = \" + str(level_ix))\n \n lum_test = np.ones((batch_size, 1)) * lum_levels[level_ix]\n \n _, image_test, sample_test, importance_scores_test = scrambler_model.predict_on_batch(x=[np.tile(np.expand_dims(x_test[test_ix], axis=0), (batch_size, 1, 1, 1)), np.tile(np.expand_dims(s_test[test_ix], axis=0), (batch_size, 1)), lum_test])\n\n y_test_hat = predictor.predict(x=[sample_test[0]], batch_size=32)[:, 0].tolist()\n \n y_test_hat_levels.append(y_test_hat)\n \n print(\" - Predictions (scrambled) = \" + str([float(str(round(y_test_hat[i], 2))[:4]) for i in range(len(y_test_hat[:10]))]))\n \n f, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(3 * 4, 3))\n\n ax1.imshow(x_test[test_ix, :, :, 0], cmap=\"Greys\", vmin=0.0, vmax=1.0, aspect='equal')\n\n plt.sca(ax1)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax2.imshow(image_test[0, :, :, 0], cmap=\"Greys\", vmin=0.0, vmax=1.0, aspect='equal')\n\n plt.sca(ax2)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax3.imshow(importance_scores_test[0, :, :, 0], cmap=\"hot\", vmin=0.0, vmax=np.max(importance_scores_test[plot_i, :, :, 0]), aspect='equal')\n \n plt.sca(ax3)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax4.imshow(x_test[test_ix, :, :, 0], cmap=\"Greys\", vmin=0.0, vmax=1.0, aspect='equal')\n\n plt.sca(ax4)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax4.imshow(importance_scores_test[0, :, :, 0], alpha=0.75, cmap=\"hot\", vmin=0.0, vmax=np.max(importance_scores_test[0, :, :, 0]), aspect='equal')\n\n plt.sca(ax4)\n plt.xticks([], [])\n plt.yticks([], [])\n\n plt.tight_layout()\n \n if save_figs :\n plt.savefig(model_name + \"_test_example_\" + str(test_ix) + \"_level_\" + str(level_ix) + \".png\", transparent=True, dpi=300)\n plt.savefig(model_name + \"_test_example_\" + str(test_ix) + \"_level_\" + str(level_ix) + \".eps\")\n \n plt.show()\n \n importance_thresh = np.quantile(np.ravel(importance_scores_test[0, :, :, 0]), q=importance_thresh_qt)\n importance_thresh = max(importance_thresh, min_importance_thresh)\n \n importance_scores_test = importance_scores_test[:1]\n \n max_lum = np.max(importance_scores_test)\n total_lum = np.sum(importance_scores_test)\n mean_lum = np.mean(importance_scores_test)\n mean_p_on = np.mean(2. / (1. + np.exp(-importance_scores_test)) - 1.)\n \n print(\"Max Luminescence (logit) = \" + str(max_lum))\n print(\"Total Luminescence (logit) = \" + str(total_lum))\n print(\"Mean Luminescence (logit) = \" + str(mean_lum))\n print(\"Target P(On) = \" + str(lum_levels[level_ix]))\n print(\"Mean P(On) = \" + str(mean_p_on))\n \n importance_scores_test[importance_scores_test < importance_thresh] = 0.\n if level_ix > 0 :\n importance_scores_levels_above = np.expand_dims(np.sum(np.concatenate(importance_scores_levels[:level_ix], axis=0), axis=0), axis=0)\n importance_scores_test[importance_scores_levels_above > 0] = 0.\n \n importance_scores_levels.append(importance_scores_test)\n \n #Calculate mean kl-divergence against background\n\n image_test_clipped = np.clip(np.copy(image_test[0, :, :, 0]), 1e-6, 1. - 1e-6)\n x_test_clipped = np.clip(np.copy(x_test[test_ix, :, :, 0]), 1e-6, 1. - 1e-6)\n\n kl_divs = (image_test_clipped * np.log(image_test_clipped / x_mean) + (1. - image_test_clipped) * np.log((1. - image_test_clipped) / (1. - x_mean))) / np.log(2.0)\n x_mean_kl_div = np.mean(kl_divs)\n\n print(\"Mean KL Div against background (bits) = \" + str(x_mean_kl_div))\n \n ces = - x_test[test_ix, :, :, 0] * np.log(image_test_clipped) / np.log(2.) - (1. - x_test[test_ix, :, :, 0]) * np.log(1. - image_test_clipped) / np.log(2.)\n x_mean_ce = np.mean(ces)\n\n print(\"Mean Cross-Entropy against example (bits) = \" + str(x_mean_ce))\n \n x_kl_divs = (x_test_clipped * np.log(x_test_clipped / image_test_clipped) + (1. - x_test_clipped) * np.log((1. - x_test_clipped) / (1. - image_test_clipped))) / np.log(2.0)\n x_kl_div = np.mean(x_kl_divs)\n\n print(\"Mean KL Div against against example (bits) = \" + str(x_kl_div))\n\n\nimport numpy.ma as ma\n\nf = plt.figure(figsize=(3, 3))\n\nplt.imshow(1. - x_test[test_ix, :, :, 0], cmap=\"Greys\", vmin=-1.0, vmax=1.0, aspect='equal')\n\ncmap_vals = [\n 0,\n 4,\n 5,\n 2\n]\n\nfor level_ix in range(n_levels) :\n \n importance_scores = importance_scores_levels[level_ix][0, :, :, 0]\n \n importance_scores_masked = ma.array(np.ones(importance_scores.shape), mask = importance_scores <= 0)\n \n plt.imshow(importance_scores_masked * cmap_vals[level_ix], alpha=1.0, cmap='Set1', vmin=0, vmax=8, aspect='equal')\n\nplt.xticks([], [])\nplt.yticks([], [])\n\nplt.tight_layout()\n\nif save_figs :\n plt.savefig(model_name + \"_test_example_\" + str(test_ix) + \"_levelset.png\", transparent=True, dpi=300)\n plt.savefig(model_name + \"_test_example_\" + str(test_ix) + \"_levelset.eps\")\n\nplt.show()\n", "Test image 0:\n - Prediction (original) = 0.0\nDepth = 0\n - Predictions (scrambled) = [0.28, 0.21, 0.16, 0.54, 0.01, 0.0, 0.06, 0.01, 0.02, 0.01]\n" ], [ "#Predict on test set\n\nsave_figs = True\n\ntest_ix = 1\n\nn_levels = 4\n\nimportance_thresh_qt = 0.0\n\nmin_importance_thresh = 10.\n\nlum_levels = [\n 0.05,\n 0.25,\n 0.45,\n 0.75\n]\n\nprint(\"Test image \" + str(test_ix) + \":\")\n \ny_test_hat_ref = predictor.predict(x=[np.expand_dims(x_test[test_ix], axis=0)], batch_size=1)[0, 0]\n\nprint(\" - Prediction (original) = \" + str(round(y_test_hat_ref, 2))[:4])\n\nimportance_scores_levels = []\ny_test_hat_levels = []\n\nfor level_ix in range(n_levels) :\n \n print(\"Depth = \" + str(level_ix))\n \n lum_test = np.ones((batch_size, 1)) * lum_levels[level_ix]\n \n _, image_test, sample_test, importance_scores_test = scrambler_model.predict_on_batch(x=[np.tile(np.expand_dims(x_test[test_ix], axis=0), (batch_size, 1, 1, 1)), np.tile(np.expand_dims(s_test[test_ix], axis=0), (batch_size, 1)), lum_test])\n\n y_test_hat = predictor.predict(x=[sample_test[0]], batch_size=32)[:, 0].tolist()\n \n y_test_hat_levels.append(y_test_hat)\n \n print(\" - Predictions (scrambled) = \" + str([float(str(round(y_test_hat[i], 2))[:4]) for i in range(len(y_test_hat[:10]))]))\n \n f, (ax1, ax2, ax3, ax4) = plt.subplots(1, 4, figsize=(3 * 4, 3))\n\n ax1.imshow(x_test[test_ix, :, :, 0], cmap=\"Greys\", vmin=0.0, vmax=1.0, aspect='equal')\n\n plt.sca(ax1)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax2.imshow(image_test[0, :, :, 0], cmap=\"Greys\", vmin=0.0, vmax=1.0, aspect='equal')\n\n plt.sca(ax2)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax3.imshow(importance_scores_test[0, :, :, 0], cmap=\"hot\", vmin=0.0, vmax=np.max(importance_scores_test[plot_i, :, :, 0]), aspect='equal')\n \n plt.sca(ax3)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax4.imshow(x_test[test_ix, :, :, 0], cmap=\"Greys\", vmin=0.0, vmax=1.0, aspect='equal')\n\n plt.sca(ax4)\n plt.xticks([], [])\n plt.yticks([], [])\n \n ax4.imshow(importance_scores_test[0, :, :, 0], alpha=0.75, cmap=\"hot\", vmin=0.0, vmax=np.max(importance_scores_test[0, :, :, 0]), aspect='equal')\n\n plt.sca(ax4)\n plt.xticks([], [])\n plt.yticks([], [])\n\n plt.tight_layout()\n \n if save_figs :\n plt.savefig(model_name + \"_test_example_\" + str(test_ix) + \"_level_\" + str(level_ix) + \".png\", transparent=True, dpi=300)\n plt.savefig(model_name + \"_test_example_\" + str(test_ix) + \"_level_\" + str(level_ix) + \".eps\")\n \n plt.show()\n \n importance_thresh = np.quantile(np.ravel(importance_scores_test[0, :, :, 0]), q=importance_thresh_qt)\n importance_thresh = max(importance_thresh, min_importance_thresh)\n \n importance_scores_test = importance_scores_test[:1]\n \n max_lum = np.max(importance_scores_test)\n total_lum = np.sum(importance_scores_test)\n mean_lum = np.mean(importance_scores_test)\n mean_p_on = np.mean(2. / (1. + np.exp(-importance_scores_test)) - 1.)\n \n print(\"Max Luminescence (logit) = \" + str(max_lum))\n print(\"Total Luminescence (logit) = \" + str(total_lum))\n print(\"Mean Luminescence (logit) = \" + str(mean_lum))\n print(\"Target P(On) = \" + str(lum_levels[level_ix]))\n print(\"Mean P(On) = \" + str(mean_p_on))\n \n importance_scores_test[importance_scores_test < importance_thresh] = 0.\n if level_ix > 0 :\n importance_scores_levels_above = np.expand_dims(np.sum(np.concatenate(importance_scores_levels[:level_ix], axis=0), axis=0), axis=0)\n importance_scores_test[importance_scores_levels_above > 0] = 0.\n \n importance_scores_levels.append(importance_scores_test)\n \n #Calculate mean kl-divergence against background\n\n image_test_clipped = np.clip(np.copy(image_test[0, :, :, 0]), 1e-6, 1. - 1e-6)\n x_test_clipped = np.clip(np.copy(x_test[test_ix, :, :, 0]), 1e-6, 1. - 1e-6)\n\n kl_divs = (image_test_clipped * np.log(image_test_clipped / x_mean) + (1. - image_test_clipped) * np.log((1. - image_test_clipped) / (1. - x_mean))) / np.log(2.0)\n x_mean_kl_div = np.mean(kl_divs)\n\n print(\"Mean KL Div against background (bits) = \" + str(x_mean_kl_div))\n \n ces = - x_test[test_ix, :, :, 0] * np.log(image_test_clipped) / np.log(2.) - (1. - x_test[test_ix, :, :, 0]) * np.log(1. - image_test_clipped) / np.log(2.)\n x_mean_ce = np.mean(ces)\n\n print(\"Mean Cross-Entropy against example (bits) = \" + str(x_mean_ce))\n \n x_kl_divs = (x_test_clipped * np.log(x_test_clipped / image_test_clipped) + (1. - x_test_clipped) * np.log((1. - x_test_clipped) / (1. - image_test_clipped))) / np.log(2.0)\n x_kl_div = np.mean(x_kl_divs)\n\n print(\"Mean KL Div against against example (bits) = \" + str(x_kl_div))\n\n\nimport numpy.ma as ma\n\nf = plt.figure(figsize=(3, 3))\n\nplt.imshow(1. - x_test[test_ix, :, :, 0], cmap=\"Greys\", vmin=-1.0, vmax=1.0, aspect='equal')\n\ncmap_vals = [\n 0,\n 4,\n 5,\n 2\n]\n\nfor level_ix in range(n_levels) :\n \n importance_scores = importance_scores_levels[level_ix][0, :, :, 0]\n \n importance_scores_masked = ma.array(np.ones(importance_scores.shape), mask = importance_scores <= 0)\n \n plt.imshow(importance_scores_masked * cmap_vals[level_ix], alpha=1.0, cmap='Set1', vmin=0, vmax=8, aspect='equal')\n\nplt.xticks([], [])\nplt.yticks([], [])\n\nplt.tight_layout()\n\nif save_figs :\n plt.savefig(model_name + \"_test_example_\" + str(test_ix) + \"_levelset.png\", transparent=True, dpi=300)\n plt.savefig(model_name + \"_test_example_\" + str(test_ix) + \"_levelset.eps\")\n\nplt.show()\n", "Test image 1:\n - Prediction (original) = 1.0\nDepth = 0\n - Predictions (scrambled) = [0.03, 0.0, 0.0, 0.0, 0.0, 0.0, 0.21, 0.0, 0.52, 0.02]\n" ] ] ]

[ "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" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "Notebook to play with some graph forms...", "_____no_output_____" ] ], [ [ "### Standard Magic and startup initializers.\n\nimport math\nimport csv\nimport numpy as np\nimport random\nimport itertools\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport pandas as pd\n\n%matplotlib inline\nmatplotlib.style.use('seaborn-whitegrid')\n\nfont = {'family' :'serif',\n 'size' : 22}\n\nmatplotlib.rc('font', **font)\n\n### Load Datafiles..\n## Load some stuff from Pickle..\nimport pickle\n\n## Open an older file\nwith open(\"./1000_stepping_run.pickle\", 'rb') as input_file:\n results = pickle.load(input_file)\n\n## Open an older file\nwith open(\"./1000_stepping_run_uniform.pickle\", 'rb') as input_file:\n uniform_results = pickle.load(input_file)\n\n# Print the keys.\nprint(\"players, tasks, sample\")\nfor k,v in results.items():\n print(k)", "players, tasks, sample\n(5, 30)\n(10, 5)\n(2, 70)\n(5, 10)\n(5, 5)\n(2, 50)\n(5, 70)\n(10, 70)\n(5, 50)\n(2, 10)\n(10, 30)\n(2, 30)\n(2, 5)\n(10, 50)\n(10, 10)\n" ], [ "df = pd.DataFrame(results)\nm = df.mean().unstack().T\ne = df.std().unstack().T\nprint(m)\nprint(e)\n#print(df.max())\n\nuf = pd.DataFrame(uniform_results)\nmu = uf.mean().unstack().T\neu = uf.std().unstack().T\nprint(mu)\nprint(eu)\n\ncolor_list = plt.cm.Paired(np.linspace(0, 1, 3))\ncolor_list = color_list[:6]\n#a = m.plot(kind='line', yerr=e.values.T, marker='*',figsize=(10,8),linewidth=3, color=color_list)\na = m.plot(kind='line', marker='*',figsize=(10,8),linewidth=3, color=color_list)\n\nhandles, labels = a.get_legend_handles_labels()\nplt.legend(loc=\"upper left\", bbox_to_anchor=[0, 1], shadow=True, title=\"Players\", fancybox=True, handles=handles[::-1], labels=labels[::-1])\n#a.legend(handles[::-1], labels[::-1])\n\nmu.plot(kind='line', yerr=eu.values.T, marker='o', ax = a, color=color_list, linestyle='--',linewidth=3, legend=False)\n#mu.plot(kind='line', marker='o', ax = a, color=color_list, linestyle='--',linewidth=3, legend=False)\n\na.set_yscale(\"log\", nonposy='clip')\na.set_xlim([0,80])\na.set_ylim([0,1000])\n#plt.legend(bbox_to_anchor = (0,0.04,1,1), bbox_transform=plt.gcf().transFigure, loc='upper center', ncol=6, borderaxespad=0.)\na.set_xlabel(\"Services Per Player ($|T_i|$)\")\na.set_ylabel(\"Solve Time (log(s))\")\nplt.tight_layout()\nplt.savefig(\"test.pdf\",bbox_inches='tight')\nplt.show()\n", " 2 5 10\n5 0.006819 0.016678 0.033212\n10 0.063348 0.178242 0.377655\n30 2.620236 9.073796 23.524422\n50 25.765830 89.238418 222.992741\n70 107.386757 379.349311 787.160301\n 2 5 10\n5 0.005216 0.010583 0.020155\n10 0.034577 0.135762 0.244456\n30 2.349703 10.141068 28.983025\n50 35.372481 118.425861 311.230165\n70 146.042514 769.699986 1004.326137\n 2 5 10\n5 0.004272 0.010473 0.020113\n10 0.029629 0.078207 0.162628\n30 0.634193 2.217992 6.046969\n50 3.111379 13.037105 46.203912\n70 9.442468 40.573399 158.673905\n 2 5 10\n5 0.001078 0.001731 0.003553\n10 0.004977 0.011571 0.028786\n30 0.093679 0.330223 0.887312\n50 0.444567 1.804271 17.048166\n70 1.382044 5.754932 62.828016\n" ] ] ]

[ "markdown", "code" ]

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/DJCordhose/ml-workshop/blob/master/notebooks/tf2/tf-dense-insurance-reg.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ] ], [ [ "# Gives us a well defined version of tensorflow\n\ntry:\n # %tensorflow_version only exists in Colab.\n %tensorflow_version 2.x\nexcept Exception:\n pass\n\n# will also work, but nightly build might contain surprises\n\n# !pip install -q tf-nightly-gpu-2.0-preview", "TensorFlow 2.x selected.\n" ], [ "import tensorflow as tf\nprint(tf.__version__)", "2.0.0-rc0\n" ], [ "import matplotlib.pyplot as plt\nimport pandas as pd\nimport tensorflow as tf\nimport numpy as np\nfrom tensorflow import keras", "_____no_output_____" ], [ "import pandas as pd\n\ndf = pd.read_csv('https://raw.githubusercontent.com/DJCordhose/ml-workshop/master/data/insurance-customers-1500.csv', sep=';')", "_____no_output_____" ], [ "y = df['group'].values\nX = df.drop('group', axis='columns').values", "_____no_output_____" ], [ "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, random_state=42, stratify=y)", "_____no_output_____" ] ], [ [ "### An experimental approach:\n- keep adding regularization to make validation and train scores come closer to each other\n- this will come at the cost of train scores going down\n- if both values start going down you have gone too far\n- each experiment takes some time\n- for larger datasets and more complex models some people start by overfitting on a subsample of the data (because it trains much faster)\n - then you can be sure you have an architecture that at least has the capacity to solve the problem\n - then keep adding regularizations\n - eventually try using the complete data\n- if you want to use batch normalization place it between raw output of neuron and activation function ", "_____no_output_____" ] ], [ [ "from tensorflow.keras.layers import Input, Dense, Dropout, \\\n BatchNormalization, Activation\n\nnum_features = 3\nnum_categories = 3\n\ndropout = 0.6\nmodel = keras.Sequential()\n\nmodel.add(Input(name='input', shape=(num_features,)))\n\n# reduce capacity by decreasing number of neurons\nmodel.add(Dense(500, name='hidden1'))\nmodel.add(Activation('relu'))\n# model.add(BatchNormalization())\n# model.add(Dropout(dropout))\n\nmodel.add(Dense(500, name='hidden2'))\nmodel.add(Activation('relu'))\n# model.add(BatchNormalization())\n# model.add(Dropout(dropout))\n\nmodel.add(Dense(name='output', units=num_categories, activation='softmax'))\n\nmodel.compile(loss='sparse_categorical_crossentropy',\n optimizer='adam',\n metrics=['accuracy'])\nmodel.summary()", "Model: \"sequential\"\n_________________________________________________________________\nLayer (type) Output Shape Param # \n=================================================================\nhidden1 (Dense) (None, 500) 2000 \n_________________________________________________________________\nactivation (Activation) (None, 500) 0 \n_________________________________________________________________\nhidden2 (Dense) (None, 500) 250500 \n_________________________________________________________________\nactivation_1 (Activation) (None, 500) 0 \n_________________________________________________________________\noutput (Dense) (None, 3) 1503 \n=================================================================\nTotal params: 254,003\nTrainable params: 254,003\nNon-trainable params: 0\n_________________________________________________________________\n" ], [ "%%time\n\n# reducing batch size might increase overfitting, \n# but might be necessary to reduce memory requirements \nBATCH_SIZE=1000\n\n# reduce this based on what you see in the training history\nEPOCHS = 10000\n\nmodel.compile(loss='sparse_categorical_crossentropy',\n optimizer='adam',\n metrics=['accuracy'])\n\nhistory = model.fit(X_train, y_train, epochs=EPOCHS, batch_size=BATCH_SIZE, validation_split=0.2, verbose=0)", "WARNING:tensorflow:Entity <function Function._initialize_uninitialized_variables.<locals>.initialize_variables at 0x7fac599677b8> could not be transformed and will be executed as-is. Please report this to the AutoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: module 'gast' has no attribute 'Num'\nWARNING: Entity <function Function._initialize_uninitialized_variables.<locals>.initialize_variables at 0x7fac599677b8> could not be transformed and will be executed as-is. Please report this to the AutoGraph team. When filing the bug, set the verbosity to 10 (on Linux, `export AUTOGRAPH_VERBOSITY=10`) and attach the full output. Cause: module 'gast' has no attribute 'Num'\nCPU times: user 3min 1s, sys: 18.6 s, total: 3min 20s\nWall time: 2min 55s\n" ], [ "train_loss, train_accuracy = model.evaluate(X_train, y_train, batch_size=BATCH_SIZE)\ntrain_loss, train_accuracy", "\r1200/1 [================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 0s 10us/sample - loss: 1.2201 - accuracy: 0.8700\n" ], [ "test_loss, test_accuracy = model.evaluate(X_test, y_test, batch_size=BATCH_SIZE)\ntest_loss, test_accuracy", "\r300/1 [========================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================] - 0s 14us/sample - loss: 1.3659 - accuracy: 0.7067\n" ], [ "plt.yscale('log')\n\nplt.ylabel(\"loss\")\nplt.xlabel(\"epochs\")\n\nplt.plot(history.history['loss'])\nplt.plot(history.history['val_loss'])\n\nplt.legend([\"Loss\", \"Valdation Loss\"])", "_____no_output_____" ], [ "plt.ylabel(\"accuracy\")\nplt.xlabel(\"epochs\")\n\nplt.plot(history.history['accuracy'])\nplt.plot(history.history['val_accuracy'])\n\nplt.legend([\"Accuracy\", \"Valdation Accuracy\"])", "_____no_output_____" ], [ "# category 1 should have the highest probability\nmodel.predict(np.array([[100, 48, 10]]))", "_____no_output_____" ], [ "assert model.predict(np.array([[100, 48, 10]])).argmax() == 1", "_____no_output_____" ], [ "", "_____no_output_____" ] ] ]

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

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

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Notebook Template\n\nThis Notebook is stubbed out with some project paths, loading of enviroment variables, and common package imports to speed up the process of starting a new project.\n\nIt is highly recommended you copy and rename this notebook following the naming convention outlined in the readme of naming notebooks with a double number such as `01-first-thing`, and `02-next-thing`. This way the order of notebooks is apparent, and each notebook does not need to be needlesssly long, complex, and difficult to follow.", "_____no_output_____" ] ], [ [ "import importlib\nimport os\nfrom pathlib import Path\nimport sys\n\nfrom arcgis.features import GeoAccessor, GeoSeriesAccessor\nfrom arcgis.gis import GIS\nfrom dotenv import load_dotenv, find_dotenv\nimport pandas as pd\n\n# import arcpy if available\nif importlib.util.find_spec(\"arcpy\") is not None:\n import arcpy", "_____no_output_____" ], [ "# paths to common data locations - NOTE: to convert any path to a raw string, simply use str(path_instance)\ndir_prj = Path.cwd().parent\n\ndir_data = dir_prj/'data'\n\ndir_raw = dir_data/'raw'\ndir_ext = dir_data/'external'\ndir_int = dir_data/'interim'\ndir_out = dir_data/'processed'\n\ngdb_raw = dir_raw/'raw.gdb'\ngdb_int = dir_int/'interim.gdb'\ngdb_out = dir_out/'processed.gdb'\n\n# import the project package from the project package path - only necessary if you are not using a unique environemnt for this project\nsys.path.append(str(dir_prj/'src'))\nimport white_pass_feature_selection\n\n# load the \"autoreload\" extension so that code can change, & always reload modules so that as you change code in src, it gets loaded\n%load_ext autoreload\n%autoreload 2\n\n# load environment variables from .env\nload_dotenv(find_dotenv())\n\n# create a GIS object instance; if you did not enter any information here, it defaults to anonymous access to ArcGIS Online\ngis = GIS(\n url=os.getenv('ESRI_GIS_URL'), \n username=os.getenv('ESRI_GIS_USERNAME'),\n password=None if len(os.getenv('ESRI_GIS_PASSWORD')) is 0 else os.getenv('ESRI_GIS_PASSWORD')\n)\n\ngis", "_____no_output_____" ] ], [ [ "Licensing\n\nCopyright 2020 Esri\n\nLicensed under the Apache License, Version 2.0 (the \"License\"); You\nmay not use this file except in compliance with the License. You may\nobtain a copy of the License at\n\nhttp://www.apache.org/licenses/LICENSE-2.0\n\nUnless required by applicable law or agreed to in writing, software\ndistributed under the License is distributed on an \"AS IS\" BASIS,\nWITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\nimplied. See the License for the specific language governing\npermissions and limitations under the License.\n\nA copy of the license is available in the repository's\nLICENSE file.", "_____no_output_____" ] ] ]

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

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

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "# Benchmarking Annotation Storage\nClick to open in: [[GitHub](https://github.com/TissueImageAnalytics/tiatoolbox/tree/master/benchmarks/annotation_store.ipynb)][[Colab](https://colab.research.google.com/github/TissueImageAnalytics/tiatoolbox/blob/master/benchmarks/annotation_store.ipynb)][[Kaggle](https://kaggle.com/kernels/welcome?src=https://github.com/TissueImageAnalytics/tiatoolbox/blob/master/benchmarks/annotation_store.ipynb)]", "_____no_output_____" ], [ "_In order to run this notebook on a Kaggle platform, 1) click the Kaggle URL 2) click on Settings on the right of the Kaggle screen, 3) log in to your Kaggle account, 4) tick \"Internet\" checkbox under Settings, to enable necessary downloads._\n\n**NOTE:** Some parts of this notebook require a lot of memory. Part 2 in particular may not run on memory constrained systems. The notebook will run well on an MacBook Air (M1, 2020) but will use a lot of swap. It may require >64GB of memory for second half to avoid using swap.", "_____no_output_____" ], [ "## About This Notebook\n\nManaging annotation, either created by hand or from model output, is a\ncommon task in computational pathology. For a small number of\nannotations this may be trivial. However, for large numbers of\nannotations, it is often necessary to store the annotations in a more\nstructured format such as a database. This is because finding a desired\nsubset of annotations within a very large collection, for example over\none million cell boundary polygons derived from running HoVerNet on a\nWSI, may be very slow if performed in a naive manner. In the toolbox, we\nimplement two storage method to make handling annotations easier:\n`DictionaryStore` and `SQLiteStore`.\n\n### Storage Classes\n\nBoth stores act as a key-value store where the key is the annotation ID\n(as a string) and the value is the annotation. This follows the Python\n[`MutableMapping`](https://docs.python.org/3/library/collections.abc.html#collections.abc.MutableMapping)\ninterface meaning that the stores can be used in the same way as a\nregular Python dictionary (`dict`).\n\nThe `DictionaryStore` is implemented internally using a Python\ndictionary. It is a realtively simple class, operating with all\nannotations in memory and using a simple scan method to search for\nannotations. This works very well for a small number of annotations. In\ncontrast the `SQLiteStore` is implemented using a SQLite database\n(either in memory or on disk), it is a more complex class making use of\nan rtree index to efficiently spatially search for annotations. This is\nmuch more suited to a very large number of annotations. However, they\nboth follow the same interface and can be used interchangeably for\nalmost all methods (`SQLiteStore` has some additional methods).\n\n### Provided Functionality (Mini Tutorial)\n\nThe storage classes provide a lot of functionality including. This\nincludes all of the standard `MutableMapping` methods, as well as\nsome additional ones for querying the collection of annotations.\nBelow is a brief summary of the main functionality.\n\n#### Adding Annotations\n\n```python\nfrom tiatoolbox.annotation.storage import Annotation, DictionaryStore, SQliteStore\nfrom shapely.geometry import Polygon\n\n# Create a new store. If no path is given it is an in-memory store.\nstore = DictionaryStore()\n\n# An annotation is a shapely geometry and a JSON serializable dictionary\nannotation = Annotation(Polygon.from_bounds(0, 0, 1, 1), {'id': '1'})\n\n# Add the annotation to the store in the same way as a dictionary\nstore[\"foo\"] = annotation\n\n# Bulk append is also supported. This will be faster in some contexts\n# (e.g. for an SQLiteStore) than adding them one at a time.\n# Here we add 100 simple box annotations.\n# As we have not specified a set of keys to use, a new UUID is generated\n# for each. The respective generated keys are also returned.\nannotations = [\n Annotation(Polygon.from_bounds(n, n, n+1, n+1), {'id': n})\n for n in range(100)\n]\nkeys = store.append_many(annotations)\n```\n\n#### Removing Annotations\n\n```python\n# Remove an annotation by key\ndel store[\"foo\"]\n\n# Bulk removal\nkeys = [\"1234-5676....\", \"...\"] # etc.\nstore.remove_many(keys)\n```\n\n\n#### Querying Within a Region\n\n```python\n# Find all annotations which intersect a polygon\nsearch_region = Polygon.from_bounds(0, 0, 10, 10)\nresult = store.query(search_region)\n\n# Find all annotations which are contained within a polygon\nsearch_region = Polygon.from_bounds(0, 0, 10, 10)\nresult = store.query(search_region, geometry_predicate=\"contains\")\n```\n\n#### Querying Using A Predicate Statement\n\n```python\n# 'props' is a provided shorthand to access the 'properties' dictionary\nresults = store.query(where=\"propd['id'] == 1\")\n```\n\n#### Serializing and Deserializing\n\n```python\n# Serialize the store to a GeoJSON string\njson_string = store.to_geojson()\n\n# Serialize the store to a GeoJSON file\nstore.to_geojson(\"boxes.geojson\")\n\n# Deserialize a GeoJSON string into a store (even of a different type)\nsqlitestore = SqliteStore.from_geojson(\"boxes.geojson\")\n\n# The above is an in-memory store. We can also now write this to disk\n# as an SQLite database.\nsqlitestore.dump(\"boxes.db\")\n```\n\n### Benchmarking\n\nHere we evaluate the storage efficient and data querying performance of\nthe annotation store versus other common formats. We will evaluate some\ncommon situations and use cases including:\n\n- Disk I/O (tested with an SSD)\n- Querying the data for annotations within a box region\n- Querying the data for annotations within a polygon region\n- Querying the data with a predicate e.g. 'class=1'\n\nAll saved output is from running this notebook on a 2020 M1 MacBook Air with 16GB RAM.", "_____no_output_____" ], [ "## Imports", "_____no_output_____" ] ], [ [ "import sys\n\nsys.path.append(\"..\") # If running locally without pypi installed tiatoolbox\n\nimport copy\nimport pickle\nimport tempfile\nimport timeit\nimport uuid\nfrom numbers import Number\nfrom pathlib import Path\nfrom typing import Generator, List, Optional, Tuple\n\nimport numpy as np\nfrom IPython.display import display\nfrom matplotlib import pyplot as plt\nfrom shapely.geometry import MultiPolygon, Point, Polygon\nfrom tqdm.auto import tqdm\n\nfrom tiatoolbox.annotation.storage import Annotation\n\nplt.style.use(\"ggplot\")\n\nfrom tiatoolbox.annotation.storage import Annotation, DictionaryStore, SQLiteStore", "_____no_output_____" ] ], [ [ "## Data Generation & Utility Functions\n\nHere we define some useful functions to generate some artificial data\nand visualise results.", "_____no_output_____" ] ], [ [ "def cell_polygon(\n xy: Tuple[Number, Number],\n n_points: int = 20,\n radius: Number = 8,\n noise: Number = 0.01,\n eccentricity: Tuple[Number, Number] = (1, 3),\n repeat_first: bool = True,\n direction: str = \"CCW\",\n seed:int = 0,\n) -> Polygon:\n \"\"\"Generate a fake cell boundary polygon.\n\n Borrowed from tiatoolbox unit tests.\n\n Cell boundaries are generated an ellipsoids with randomised eccentricity,\n added noise, and a random rotation.\n\n Args:\n xy (tuple(int)): The x,y centre point to generate the cell boundary around.\n n_points (int): Number of points in the boundary. Defaults to 20.\n radius (float): Radius of the points from the centre. Defaults to 10.\n noise (float): Noise to add to the point locations. Defaults to 1.\n eccentricity (tuple(float)): Range of values (low, high) to use for\n randomised eccentricity. Defaults to (1, 3).\n repeat_first (bool): Enforce that the last point is equal to the first.\n direction (str): Ordering of the points. Defaults to \"CCW\". Valid options\n are: counter-clockwise \"CCW\", and clockwise \"CW\".\n seed: Seed for the random number generator. Defaults to 0.\n\n \"\"\"\n from shapely import affinity\n \n rand_state = np.random.get_state()\n np.random.seed(seed)\n if repeat_first:\n n_points -= 1\n\n # Generate points about an ellipse with random eccentricity\n x, y = xy\n alpha = np.linspace(0, 2 * np.pi - (2 * np.pi / n_points), n_points)\n rx = radius * (np.random.rand() + 0.5)\n ry = np.random.uniform(*eccentricity) * radius - 0.5 * rx\n x = rx * np.cos(alpha) + x + (np.random.rand(n_points) - 0.5) * noise\n y = ry * np.sin(alpha) + y + (np.random.rand(n_points) - 0.5) * noise\n boundary_coords = np.stack([x, y], axis=1).astype(int).tolist()\n\n # Copy first coordinate to the end if required\n if repeat_first:\n boundary_coords = boundary_coords + [boundary_coords[0]]\n\n # Swap direction\n if direction.strip().lower() == \"cw\":\n boundary_coords = boundary_coords[::-1]\n\n polygon = Polygon(boundary_coords)\n\n # Add random rotation\n angle = np.random.rand() * 360\n polygon = affinity.rotate(polygon, angle, origin=\"centroid\")\n\n\n # Restore the random state\n np.random.set_state(rand_state)\n \n return polygon", "_____no_output_____" ], [ "def cell_grid(\n size: Tuple[int, int] = (10, 10), spacing: Number = 25\n) -> Generator[Polygon, None, None]:\n \"\"\"Generate a grid of cell boundaries.\"\"\"\n return (\n cell_polygon(xy=np.multiply(ij, spacing), repeat_first=False, seed=n)\n for n, ij in enumerate(np.ndindex(size))\n )", "_____no_output_____" ], [ "def plot_results(\n experiments: List[List[Number]], title: str, capsize=5, **kwargs\n) -> None:\n \"\"\"Plot the results of a benchmark.\n\n Uses the min for the bar height (see See\n https://docs.python.org/2/library/timeit.html#timeit.Timer.repeat),\n and plots a min-max error bar.\n \n \"\"\"\n import matplotlib.patheffects as PathEffects\n\n x = range(len(experiments))\n color = [f\"C{x_i}\" for x_i in x]\n plt.bar(\n x=x,\n height=[min(e) for e in experiments],\n color=color,\n yerr=[[0 for e in experiments], [max(e) - min(e) for e in experiments]],\n capsize=capsize,\n **kwargs,\n )\n for i, (runs, c) in enumerate(zip(experiments, color)):\n plt.text(\n i,\n min(runs),\n f\" {min(runs):.4f}s\",\n ha=\"left\",\n va=\"bottom\",\n color=c,\n zorder=10,\n fontweight=\"bold\",\n path_effects=[\n PathEffects.withStroke(linewidth=2, foreground=\"w\"),\n ],\n )\n plt.title(title)\n plt.hlines(\n 0.5,\n -0.5,\n len(experiments) - 0.5,\n linestyles=\"dashed\",\n colors=\"black\",\n alpha=0.5,\n )\n plt.yscale(\"log\")\n plt.xlabel(\"Store Type\")\n plt.ylabel(\"Time (s)\")", "_____no_output_____" ] ], [ [ "## Display Some Generated Data\n", "_____no_output_____" ] ], [ [ "for n in range(4):\n display(cell_polygon(xy=(0, 0), n_points=20, repeat_first=False, seed=n))", "_____no_output_____" ] ], [ [ "### Randomised Cell Boundaries\n\nHere we create a function to generate grid of cells for testing. It uses a fixed seed for reproducibility.\n", "_____no_output_____" ], [ "### A Sample 5×5 Grid\n", "_____no_output_____" ] ], [ [ "from shapely.geometry import MultiPolygon\n\nMultiPolygon(polygons=list(cell_grid(size=(5, 5), spacing=35)))", "_____no_output_____" ] ], [ [ "# Part 1: Small Scale Benchmarking of Annotation Storage\n\nUsing the already defined data generation functions (`cell_polygon` and\n`cell_grid`), we create some simple artificial cell boundaries by\ncreating a circle of points, adding some noise, scaling to introduce\neccentricity, and then rotating. We use 20 points per cell, which is a\nreasonably high value for cell annotation. However, this can be\nadjusted.\n", "_____no_output_____" ], [ "## 1.1) Appending Annotations (In-Memory & Disk I/O)\n\nHere we test:\n\n1. A python dictionary based in-memory store (`DictionaryStore`)\n2. An SQLite database based in-memory store (`SQLiteStore`)\n\nBoth of these stores may operate in memory. The `SQLiteStore` may also\nbe backed by an on-disk file for datasets which are too large to fit in\nmemory. The `DictionaryStore` class can serialise/deserialise itself\nto/from disk in a line delimited GeoJSON format (each line seperated\nby `\\n` is a valid GeoJSON object)", "_____no_output_____" ] ], [ [ "# Convert to annotations (a dataclass pairing a geometry and (optional)\n# key-value properties)\n# Run time: ~2s\nannotations = [\n Annotation(polygon) for polygon in cell_grid(size=(100, 100), spacing=35)\n]", "_____no_output_____" ] ], [ [ "### 1.1.1) In Memory Append", "_____no_output_____" ] ], [ [ "# Run time: ~5s\n\n# Time dictionary store\ndict_runs = timeit.repeat(\n \"dict_store.append_many(annotations)\",\n setup=\"dict_store = DictionaryStore()\",\n globals={\"DictionaryStore\": DictionaryStore, \"annotations\": annotations},\n number=1,\n repeat=3,\n)\n\n# Time SQLite store\nsqlite_runs = timeit.repeat(\n \"sql_store.append_many(annotations)\",\n setup=\"sql_store = SQLiteStore()\",\n globals={\"SQLiteStore\": SQLiteStore, \"annotations\": annotations},\n number=1,\n repeat=3,\n)\n\n# Plot the results\nplot_results(\n experiments=[dict_runs, sqlite_runs],\n title=\"Time to Append 10,000 Annotations In Memory\",\n tick_label=[\"DictionaryStore\", \"SQLiteStore\"],\n)\nplt.hlines(0.5, -0.5, 1.5, linestyles=\"dashed\", color=\"k\")\nplt.xlim([-0.5, 1.5])\nplt.show()", "_____no_output_____" ] ], [ [ "Note that inserting into the `SQLiteStore` is much slower than the\n`DictionaryStore`. Appending to a `Dictionary` store simply requires\nadding a memory reference to a dictionary. Therefore, this is a very\nfast operation. On the other hand, for the `SQLiteStore`, the insertion\nis slower because the data must be serialised for the database and the\nR-Tree spatial index must also be updated. Updating the index is a\nrelatively expensive operation. However, this spatial index allows for\nvery fast queries of a very large set of annotations within a set of\nspatial bounds.\n\nInsertion is typically only performed once for each\nannotation, whereas queries may be performed many times on the\nannotation set. Therefore, it makes sense to trade a more expensive\ninsertion for fast queries as the cost of insertion will be amortised\nover a number of queries on the data. Additionally, data may be written\nto the database from multiple threads or subprocesses (so long as a new\ninstance of `SQLiteStore` is created for each thread or subprocess to\nattach to a database on disk) thus freeing up the main thread.\n\nFor comparison, we also compare bulk insertion plus seralising to disk\nas line-delimited GeoJSON from the `DictionaryStore` as this is the\ndefault serialisation to disk method (`DictionaryStore.dump(file_path`).", "_____no_output_____" ] ], [ [ "# Run time: ~10s\n\nsetup = \"fp.truncate(0)\\n\" \"store = Store(fp)\" # Clear the file\n\n# Time dictionary store\nwith tempfile.NamedTemporaryFile(\"w+\") as fp:\n dict_runs = timeit.repeat(\n (\"store.append_many(annotations)\\n\" \"store.commit()\"),\n setup=setup,\n globals={\"Store\": DictionaryStore, \"annotations\": annotations, \"fp\": fp},\n number=1,\n repeat=3,\n )\n\n# Time SQLite store\nwith tempfile.NamedTemporaryFile(\"w+b\") as fp:\n sqlite_runs = timeit.repeat(\n (\"store.append_many(annotations)\\n\" \"store.commit()\"),\n setup=setup,\n globals={\"Store\": SQLiteStore, \"annotations\": annotations, \"fp\": fp},\n number=1,\n repeat=3,\n )\n\n# Plot the results\nplot_results(\n experiments=[dict_runs, sqlite_runs],\n title=\"Time to Append & Serialise 10,000 Annotations To Disk\",\n tick_label=[\"DictionaryStore\", \"SQLiteStore\"],\n)\nplt.hlines(0.5, -0.5, 1.5, linestyles=\"dashed\", color=\"k\")\nplt.xlim([-0.5, 1.5])\nplt.show()", "_____no_output_____" ] ], [ [ "Here we can see that when we include the serialisation to disk in the\nbenchmark, the time to insert is much more similar.", "_____no_output_____" ], [ "## 1.2) Box Query", "_____no_output_____" ] ], [ [ "# Run time: ~20s\n\n# One time Setup\ndict_store = DictionaryStore()\nsql_store = SQLiteStore()\ndict_store.append_many(annotations)\nsql_store.append_many(annotations)\n\nnp.random.seed(123)\nboxes = [\n Polygon.from_bounds(x, y, 128, 128)\n for x, y in np.random.randint(0, 1000, size=(100, 2))\n]\nstmt = \"for box in boxes:\\n\" \" _ = store.query(box)\"\n\n# Time dictionary store\ndict_runs = timeit.repeat(\n stmt,\n globals={\"store\": dict_store, \"boxes\": boxes},\n number=1,\n repeat=10,\n)\n\n# Time SQLite store\nsqlite_runs = timeit.repeat(\n stmt,\n globals={\"store\": sql_store, \"boxes\": boxes},\n number=1,\n repeat=10,\n)\n\n# Plot the results\nplot_results(\n experiments=[dict_runs, sqlite_runs],\n title=\"100 Box Queries\",\n tick_label=[\"DictionaryStore\", \"SQLiteStore\"],\n)\nplt.show()", "_____no_output_____" ] ], [ [ "Here we can see that the `SQLiteStore` is a bit faster. Addtionally,\ndifference in performance is more pronounced when there are more\nannotations (as we will see later in this notebook) in the store or when\njust returning keys:", "_____no_output_____" ] ], [ [ "# Run time: ~15s\n\n# One time Setup\ndict_store = DictionaryStore()\nsql_store = SQLiteStore()\ndict_store.append_many(annotations)\nsql_store.append_many(annotations)\n\nnp.random.seed(123)\nboxes = [\n Polygon.from_bounds(x, y, 128, 128)\n for x, y in np.random.randint(0, 1000, size=(100, 2))\n]\nstmt = \"for box in boxes:\\n\" \" _ = store.iquery(box)\" # Just return the keys (uuids)\n\n# Time dictionary store\ndict_runs = timeit.repeat(\n stmt,\n globals={\"store\": dict_store, \"boxes\": boxes},\n number=1,\n repeat=10,\n)\n\n# Time SQLite store\nsqlite_runs = timeit.repeat(\n stmt,\n globals={\"store\": sql_store, \"boxes\": boxes},\n number=1,\n repeat=10,\n)\n\n# Plot the results\nplot_results(\n experiments=[dict_runs, sqlite_runs],\n title=\"100 Box Queries (Key Lookup Only)\",\n tick_label=[\"DictionaryStore\", \"SQLiteStore\"],\n)\nplt.show()", "_____no_output_____" ] ], [ [ "## 1.3) Polygon Query", "_____no_output_____" ] ], [ [ "# Run time: ~15s\n\n# One time Setup\ndict_store = DictionaryStore()\nsql_store = SQLiteStore()\ndict_store.append_many(annotations)\nsql_store.append_many(annotations)\n\nnp.random.seed(123)\nquery_polygons = [\n Polygon(\n [\n (x, y),\n (x + 128, y),\n (x + 128, y + 128),\n (x, y),\n ]\n )\n for x, y in np.random.randint(0, 1000, size=(100, 2))\n]\nstmt = \"for polygon in query_polygons:\\n\" \" _ = store.query(polygon)\"\n\n# Time dictionary store\ndict_runs = timeit.repeat(\n stmt,\n globals={\"store\": dict_store, \"query_polygons\": query_polygons},\n number=1,\n repeat=10,\n)\n\n# Time SQLite store\nsqlite_runs = timeit.repeat(\n stmt,\n globals={\"store\": sql_store, \"query_polygons\": query_polygons},\n number=1,\n repeat=10,\n)\n\n# Plot the results\nplot_results(\n experiments=[dict_runs, sqlite_runs],\n title=\"100 Polygon Queries\",\n tick_label=[\"DictionaryStore\", \"SQLiteStore\"],\n)\nplt.show()", "_____no_output_____" ] ], [ [ "Here we can see that performing queries within a polygon region is about\n10x faster with the `SQLiteStore` than with the `DictionaryStore`.", "_____no_output_____" ], [ "## 1.4) Predicate Query\n\nHere we query the whole annotation region but with a predicate to\nselect only annotations with the class label of 0. We also,\ndemonstrate how creating a database index can dramatically improve\nthe performance of queries.", "_____no_output_____" ] ], [ [ "# Run time: ~2m\n\n# Setup\nlabelled_annotations = copy.deepcopy(annotations)\nfor n, annotation in enumerate(labelled_annotations):\n annotation.properties[\"class\"] = n % 10\n annotation.properties[\"vector\"] = np.random.randint(1, 4, 10).tolist()\n\npredicate = \"(props['class'] == ?) & (3 in props['vector'])\"\nclasses = np.random.randint(0, 10, size=100)\nstmt = \"for n in classes:\\n\" \" store.query(where=predicate.replace('?', str(n)))\"\n\ndict_store = DictionaryStore()\nsql_store = SQLiteStore()\n\ndict_store.append_many(labelled_annotations)\nsql_store.append_many(labelled_annotations)\n\n\n# Time dictionary store\ndict_runs = timeit.repeat(\n stmt,\n globals={\"store\": dict_store, \"predicate\": predicate, \"classes\": classes},\n number=1,\n repeat=10,\n)\ndict_result = dict_store.query(where=predicate.replace(\"?\", \"0\"))\n\n# Time SQLite store\nsqlite_runs = timeit.repeat(\n stmt,\n globals={\"store\": sql_store, \"predicate\": predicate, \"classes\": classes},\n number=1,\n repeat=10,\n)\nsql_result = sql_store.query(where=predicate.replace(\"?\", \"0\"))\n\n\n# Add an index\n# Note: Indexes may not always speed up the query (sometimes they can\n# actually slow it down), test to make sure.\nsql_store.create_index(\"class_lookup\", \"props['class']\")\nsql_store.create_index(\"has_3\", \"3 in props['vector']\")\n\n# Time SQLite store again\nsqlite_index_runs = timeit.repeat(\n stmt,\n globals={\"store\": sql_store, \"predicate\": predicate, \"classes\": classes},\n number=1,\n repeat=10,\n)\nsql_index_result = sql_store.query(where=predicate.replace(\"?\", \"0\"))\n\n# # Validate the results against each other\n# for a, b, c in zip(dict_result, sql_result, sql_index_result):\n# assert a.geometry == b.geometry == c.geometry\n\n# Plot the results\nplot_results(\n experiments=[dict_runs, sqlite_runs, sqlite_index_runs],\n title=\"100 Queries with a Predicate\",\n tick_label=[\"DictionaryStore\", \"SQLiteStore\", \"SQLiteStore\\n(with index)\"],\n)\nplt.show()", "_____no_output_____" ] ], [ [ "### Polygon & Predicate Query", "_____no_output_____" ] ], [ [ "# Run time: ~10s\n\n# Setup\nlabelled_annotations = copy.deepcopy(annotations)\nfor n, annotation in enumerate(labelled_annotations):\n annotation.properties[\"class\"] = n % 10\n\npredicate = \"props['class'] == \"\nclasses = np.random.randint(0, 10, size=50)\nquery_polygons = [\n Polygon(\n [\n (x, y),\n (x + 128, y),\n (x + 128, y + 128),\n (x, y),\n ]\n )\n for x, y in np.random.randint(0, 1000, size=(100, 2))\n]\nstmt = (\n \"for n, poly in zip(classes, query_polygons):\\n\"\n \" store.query(poly, where=predicate + str(n))\"\n)\n\ndict_store = DictionaryStore()\nsql_store = SQLiteStore()\n\ndict_store.append_many(labelled_annotations)\nsql_store.append_many(labelled_annotations)\n\n\n# Time dictionary store\ndict_runs = timeit.repeat(\n stmt,\n globals={\n \"store\": dict_store,\n \"predicate\": predicate,\n \"classes\": classes,\n \"query_polygons\": query_polygons,\n },\n number=1,\n repeat=10,\n)\ndict_result = dict_store.query(query_polygons[0], where=predicate + \"0\")\n\n# Time SQLite store\nsqlite_runs = timeit.repeat(\n stmt,\n globals={\n \"store\": sql_store,\n \"predicate\": predicate,\n \"classes\": classes,\n \"query_polygons\": query_polygons,\n },\n number=1,\n repeat=10,\n)\nsql_result = sql_store.query(query_polygons[0], where=predicate + \"0\")\n\n\n# Check that the set difference of bounding boxes is empty i.e. all sets\n# of results contain polygons which produce the same set of bounding\n# boxes. This avoids being tripped up by slight varations in order or\n# coordinate order between the results.\ndict_set = set(x.geometry.bounds for x in dict_result)\nsql_set = set(x.geometry.bounds for x in sql_result)\nassert len(dict_set.difference(sql_set)) == 0\n\n# Plot the results\nplot_results(\n experiments=[dict_runs, sqlite_runs],\n title=\"100 Queries with a Polygon and Predicate\",\n tick_label=[\"DictionaryStore\", \"SQLiteStore\"],\n)\nplt.show()", "_____no_output_____" ] ], [ [ "### Complex Predicate Query\n\nHere we slightly increase the complexity of the predicate to show how\nthe complexity of a predicate can dramatically affect the performance\nwhen handling many annotations.", "_____no_output_____" ] ], [ [ "# Run time: ~1m\n\n# Setup\nbox = Polygon.from_bounds(0, 0, 1024, 1024)\nlabelled_annotations = copy.deepcopy(annotations)\nfor n, annotation in enumerate(labelled_annotations):\n annotation.properties[\"class\"] = n % 4\n annotation.properties[\"n\"] = n\n\npredicate = \"(props['n'] > 1000) & (props['n'] % 4 == 0) & (props['class'] == \"\ntargets = np.random.randint(0, 4, size=100)\nstmt = \"for n in targets:\\n\" \" store.query(box, where=predicate + str(n) + ')')\"\n\ndict_store = DictionaryStore()\nsql_store = SQLiteStore()\n\ndict_store.append_many(labelled_annotations)\nsql_store.append_many(labelled_annotations)\n\n\n# Time dictionary store\ndict_runs = timeit.repeat(\n stmt,\n globals={\n \"store\": dict_store,\n \"predicate\": predicate,\n \"targets\": targets,\n \"box\": box,\n },\n number=1,\n repeat=10,\n)\ndict_result = dict_store.query(box, where=predicate + \"0)\")\n\n# Time SQLite store\nsqlite_runs = timeit.repeat(\n stmt,\n globals={\n \"store\": sql_store,\n \"predicate\": predicate,\n \"targets\": targets,\n \"box\": box,\n },\n number=1,\n repeat=10,\n)\nsql_result = sql_store.query(box, where=predicate + \"0)\")\n\n\n# Check that the set difference of bounding boxes is empty i.e. all sets\n# of results contain polygons which produce the same set of bounding\n# boxes. This avoids being tripped up by slight varations in order or\n# coordinate order between the results.\ndict_set = set(x.geometry.bounds for x in dict_result.values())\nsql_set = set(x.geometry.bounds for x in sql_result.values())\n\nassert len(dict_set.difference(sql_set)) == 0\n\n# Plot the results\nplot_results(\n experiments=[dict_runs, sqlite_runs],\n title=\"100 Queries with a Complex Predicate\",\n tick_label=[\"DictionaryStore\", \"SQLiteStore\"],\n)\nplt.show()", "_____no_output_____" ] ], [ [ "# Part 2: Large Scale Dataset Benchmarking\n\nHere we generate some sets of anntations with five million items each\n(in a 2237 x 2237 grid). One is a set of points, the other a set of\ngenerated cell boundaries.\n\nThe code to generate and write out the annotations to various formats is\nincluded in the following cells. However, some of these take a very long\ntime to run. A pre-generated dataset is downloaded and then read from\ndisk instead to save time. However, you may uncomment the generation\ncode to replicate the original.\n", "_____no_output_____" ], [ "## 2.1) Points Dataset\n\nHere we generate a simple points data in a grid. The grid is 2237 x 2237\nand contains over 5 million points. We also write this to disk in\nvarious formats. Some formats take a long time and are commented out. A\nsummary of times for a consumer laptop are shown in a table at the end.", "_____no_output_____" ] ], [ [ "# Generate some points with a little noise\n# Run time: ~5s\npoints = np.array(\n [[x, y] for x in np.linspace(0, 75_000, 2237) for y in np.linspace(0, 75_000, 2237)]\n)\n# Add some noise between -1 and 1\nnp.random.seed(42)\npoints += np.random.uniform(-1, 1, size=(2237**2, 2))", "_____no_output_____" ] ], [ [ "### 2.1.1) Writing To Disk", "_____no_output_____" ] ], [ [ "# Save as a simple Numpy array (.npy)\n# Run time: <1s\nnp.save(\"points.npy\", points)", "_____no_output_____" ], [ "# Save as compressed NumPy archive (.npz)\n# Run time: ~5s\nnp.savez_compressed(\"points.npz\", points)", "_____no_output_____" ] ], [ [ "Note that the above numpy format is missing the keys (UUIDs) of each point.\nThis may not be required in all cases. However, for the sake of comparison\nwe also generate a NumPy archive with keys included. We store the UUIDs\nas integers to save space and for a fair comparison where the optimal\nstorage method is used in each case. Note however that UUIDs are too\nlarge to be a standard C type and therefore are stored as an object\narray.", "_____no_output_____" ] ], [ [ "# Generate UUIDs\n# Run time: ~10s\nkeys = np.array([uuid.uuid4().int for _ in range(len(points))])", "_____no_output_____" ], [ "# Generate some UUIDs as keys\n# Save in NumPy format (.npz)\n# Run time: <1s\nnp.savez(\"uuid_points.npz\", keys=keys, coords=points)", "_____no_output_____" ], [ "# Save in compressed (zip) NumPy format (.npz)\n# Run time: ~10s\nnp.savez_compressed(\"uuid_points_compressed.npz\", keys=keys, coords=points)", "_____no_output_____" ], [ "# Write to SQLite with SQLiteStore\n# Run time: ~10m\npoints_sqlite_store = SQLiteStore(\"points.db\")\n_ = points_sqlite_store.append_many(annotations=(Annotation(Point(x, y)) for x, y in points))", "_____no_output_____" ], [ "# Load a DictionaryStore into memory by copying from the SQLiteStore\n# Run time: ~1m 30s\npoints_dict_store = DictionaryStore(Path(\"points.ndjson\"))\nfor key, value in points_sqlite_store.items():\n points_dict_store[key] = value", "_____no_output_____" ], [ "# Save as GeoJSON\n# Run time: ~1m 30s\npoints_sqlite_store.to_geojson(\"points.geojson\")", "_____no_output_____" ], [ "# Save as ndjson\n# Run time: ~1m 30s\n# Spec: https://github.com/ndjson/ndjson-spec\npoints_sqlite_store.to_ndjson(\"points.ndjson\")", "_____no_output_____" ] ], [ [ "### 2.1.2) Points Dataset Statistics Summary\n\n| Format | Write Time | Size |\n|-------------------------------:|-----------:|-------:|\n| SQLiteStore (.db) | 6m 20s | 893MB |\n| ndjson | 1m 23s | 667 MB |\n| GeoJSON | 1m 42s | 500 MB |\n| NumPy + UUID (.npz) | 0.5s | 165 MB |\n| NumPy + UUID Compressed (.npz) | 31s | 136 MB |\n| NumPy (.npy) | 0.1s | 76 MB |\n| NumPy Compressed (.npz) | 3.3s | 66 MB |\n\n\nNote that the points SQLite database is significantly larger than the\nNumPy arrays on disk. The numpy array is much more storage efficient\npartly because there is no R Tree index or unique identifier (UUID)\nstored for each point. For a more fair comparison, another NumPy archive\n(.npz) is created where the keys are stored along with the coordinates.\n\nAlso note that although the compressed NumPy representation is much\nsmaller, it must be decompressed in memeory before it can be used. The\nuncompressed versions may be memory mapped if their size exceeds the\navailable memory.", "_____no_output_____" ], [ "### 2.1.3) Simple Box Query\n\nHere we evaluate the performance of performing a simple box query on the\ndata. All points which are in the area between 128 and 256 in the x and\ny coordinates are retrieved. It is assumed that the data is already in\nmemory for the NumPy formats. In reality this would not the be case for\nthe first query, all data would have to be read from disk, which is a\nsignifican overhead. However, this cost is amortised across many\nqueries. To ensure the fairest possible comparison, it is assumed that\nmany queries will be performed, and that this data loading cost in\nnegligable.", "_____no_output_____" ] ], [ [ "box = Polygon.from_bounds(128, 128, 256, 256)\n\n# Time numpy\nnumpy_runs = timeit.repeat(\n (\n \"where = np.all([\"\n \"points[:, 0] > 128,\"\n \"points[:, 0] < 256,\"\n \"points[:, 1] > 128,\"\n \"points[:, 1] < 256\"\n \"], 0)\\n\"\n \"uuids = keys[where]\\n\"\n \"result = points[where]\\n\"\n ),\n globals={\"keys\": keys, \"points\": points, \"np\": np},\n number=1,\n repeat=10,\n)\n\n# Time SQLiteStore\nsqlite_runs = timeit.repeat(\n \"store.query(box)\",\n globals={\"store\": points_sqlite_store, \"box\": box},\n number=1,\n repeat=10,\n)\n\n# Time DictionaryStore\ndict_runs = timeit.repeat(\n \"store.query(box)\",\n globals={\"store\": points_dict_store, \"box\": box},\n number=1,\n repeat=10,\n)", "_____no_output_____" ], [ "plot_results(\n experiments=[dict_runs, sqlite_runs, numpy_runs],\n title=\"Points Box Query (5 Million Points)\",\n tick_label=[\"DictionaryStore\", \"SQLiteStore\", \"NumPy Array\"],\n)\nplt.show()", "_____no_output_____" ] ], [ [ "Although the NumPy array is very space efficient on disk, it is not as\nfast to query as the `SQLiteStore`. The `SQLiteStore` is likely faster\ndue to the use of the R tree index. Furthermore, the method used to\nstore the points in a NumPy array is limited in that it does not use\nUUIDs, which makes merging two datasets more difficult as the indexes of\npoints no longer uniquely identify them. Additionally, only homogeneous\ndata such as two-dimentional coordinates can be practically stored in\nthis way. If the user would like to store variable length data\nstructures such as polygons, or even mix data types by storing both\npoints and polygons, then using raw NumPy arrays in this way can become\ncumbersome and begins to offer little benefit in terms of storage\nefficient or query performance.", "_____no_output_____" ], [ "### 2.1.4) Polygon Query", "_____no_output_____" ] ], [ [ "big_triangle = Polygon(\n shell=[\n (1024, 1024),\n (1024, 4096),\n (4096, 4096),\n (1024, 1024),\n ]\n)\n\n# Time SQLiteStore\nsqlite_runs = timeit.repeat(\n \"store.query(polygon)\",\n globals={\"store\": points_sqlite_store, \"polygon\": big_triangle},\n number=1,\n repeat=10,\n)\n\n# Time DictionaryStore\ndict_runs = timeit.repeat(\n \"store.query(polygon)\",\n globals={\"store\": points_dict_store, \"polygon\": big_triangle},\n number=1,\n repeat=10,\n)", "_____no_output_____" ], [ "plot_results(\n experiments=[dict_runs, sqlite_runs],\n title=\"Polygon Query (5 Million Points)\",\n tick_label=[\"DictionaryStore\", \"SQLiteStore\"],\n)\nplt.show()", "_____no_output_____" ] ], [ [ "## 2.2) Cell Boundary Polygons Dataset\n\nHere we generate a much larger and more complex polygon dataset. This\nconsistes of a grid of over 5 million generated cell boundary like\npolygons.", "_____no_output_____" ] ], [ [ "# Generate a grid of 5 million cell boundary polygons (2237 x 2237)\n# Run time: ~10m\n\nimport random\nrandom.seed(42)\n\ncell_polygons = [\n Annotation(geometry=polygon, properties={\"class\": random.randint(0, 4)})\n for polygon\n in tqdm(cell_grid(size=(2237, 2237), spacing=35), total=2237**2)\n]", "100%|██████████| 5004169/5004169 [10:04<00:00, 8277.35it/s] \n" ] ], [ [ "### 2.2.1) Write To Formats For Comparison", "_____no_output_____" ] ], [ [ "# Write to an SQLiteStore on disk (SSD for recorded times here)\n# Run time: ~30m\ncell_sqlite_store = SQLiteStore(\"cells.db\")\n_ = cell_sqlite_store.append_many(annotations=cell_polygons)", "_____no_output_____" ], [ "# Create a copy as an in memory DictionaryStore\n# Run time: ~5m\ncell_dict_store = DictionaryStore()\nfor key, value in tqdm( # Show a nice progress bar\n cell_sqlite_store.items(),\n total=len(cell_sqlite_store),\n leave=False,\n position=0,\n):\n cell_dict_store[key] = value", " \r" ], [ "# Transform into a numpy array\n# Run Time: ~1m\ncell_polygons_np = np.array(\n [np.array(a.geometry.exterior.coords) for a in tqdm(cell_polygons)],\n dtype=object\n)", "100%|██████████| 5004169/5004169 [01:26<00:00, 58002.74it/s]\n" ], [ "# Create an Nx4 index of (xmin, ymin, xmax, ymax) as a simple spatial\n# index to speed up the numpy query.\n# Run time: ~1m\nmin_max_index = np.array(\n [(*np.min(coords, 0), *np.max(coords, 0)) for coords in cell_polygons_np]\n)", "_____no_output_____" ], [ "# Write to GeoJSON\n# Run time: ~10m\n\ncell_dict_store.to_geojson(\"cells.geojson\")", "_____no_output_____" ], [ "# Write to line delimited JSON (ndjson)\n# Run time: ~10m\n\ncell_dict_store.to_ndjson(\"cells.ndjson\")", "_____no_output_____" ], [ "# Zstandard compression of ndjson to demonstrate how well it compresses.\n# Gzip may also be used but is slower to compress.\n# Run time: ~1m\n! zstd -f -k cells.ndjson -o cells.ndjson.zstd", "cells.ndjson : 40.82% ( 8.82 GiB => 3.60 GiB, cells.ndjson.zstd) \n" ], [ "# Zstandard compression of sqlite to demonstrate how well it compresses.\n# Gzip may also be used but is slower to compress.\n# Run time: ~20s\n! zstd -f -k cells.db -o cells.db.zstd", "cells.db : 75.87% ( 4.87 GiB => 3.69 GiB, cells.db.zstd) \n" ], [ "# Write as a pickle (list)\n# Run time: ~2m\nwith open(\"cells.pickle\", \"wb\") as fh:\n pickle.dump(cell_polygons, fh)", "_____no_output_____" ], [ "# Write as a pickle (dict)\n# Run time: ~15m\nwith open(\"cells-dict.pickle\", \"wb\") as fh:\n pickle.dump(cell_dict_store._rows, fh)", "_____no_output_____" ], [ "# Write dictionary store to a pickle\n# Run time: ~20m\nwith open(\"cells.pickle\", \"wb\") as fh:\n pickle.dump(cell_dict_store, fh)", "_____no_output_____" ], [ "# Write as numpy object array (similar to writing out with pickle),\n# Numpy cannot handle ragged arrays and therefore dtype must be object.\n# Run time: ~30m\nnp.save(\"cells.npy\", np.asanyarray(cell_polygons_np, dtype=object))", "_____no_output_____" ], [ "# Create UUIDs, and get the class labels for each cell boundary\n# Run time: ~2m\n_uuids = [str(uuid.uuid4) for _ in cell_polygons]\n_cls = [x.properties[\"class\"] for x in cell_polygons]", "_____no_output_____" ], [ "# Write as NumPy archive (.npz) with uuid and min_max_index\n# Run time: ~40m\nnp.savez(\n \"cells.npz\",\n uuids=_uuids,\n polygons=cell_polygons_np,\n min_max_index=min_max_index,\n cls=_cls,\n)\n\ndel _uuids, _cls", "_____no_output_____" ] ], [ [ "### 2.2.2) Time To Write Summary Statistics\n\nThe following is a summary of the time required to write each format to\ndisk and the total disk space occupied by the final output.\n\nNote that some of these formats, such as GeoJSON compress well with\nschemes such as gzip and zstd, reducing the disk space by approximately\nhalf. Statistics for zstd compressed data is also reported below. It\nshould be noted that the data must be decompressed to be usable.\nHowever, for gzip and zstd, this may be done in a streaming fashion from\ndisk.\n\n| Format | Write Time | Size |\n|------------------:|------------:|--------:|\n| SQLiteStore (.db) |33m 48.4s | 4.9 GB |\n| GeoJSON |11m 32.9s | 8.9 GB |\n| ndjson |9m 0.9s | 8.8 GB |\n| pickle |1m 2.9s | 1.8 GB |\n| zstd (SQLite) |18.2s | 3.7 GB |\n| zstd (ndjson) |43.7s | 3.6 GB |\n| NumPy (.npy) |50.3s | 1.8 GB |\n| NumPy (.npz) |55.3s | 2.6 GB |\n", "_____no_output_____" ], [ "### 2.2.3) Box Query", "_____no_output_____" ] ], [ [ "# Run time: ~5m\n\n# Setup\nxmin, ymin, xmax, ymax = 128, 12, 256, 256\nbox = Polygon.from_bounds(xmin, ymin, xmax, ymax)\n\n\n# Time DictionaryStore\ndict_runs = timeit.repeat(\n \"store.query(box)\",\n globals={\"store\": cell_dict_store, \"box\": box},\n number=1,\n repeat=3,\n)\n\n# Time SQLite store\nsqlite_runs = timeit.repeat(\n \"store.query(box)\",\n globals={\"store\": cell_sqlite_store, \"box\": box},\n number=1,\n repeat=3,\n)", "_____no_output_____" ], [ "# Plot results\nplot_results(\n experiments=[dict_runs, sqlite_runs],\n title=\"Box Query (5 Million Polygons)\",\n tick_label=[\n \"DictionaryStore\",\n \"SQLiteStore\",\n ],\n)\nplt.show()", "_____no_output_____" ] ], [ [ "### 2.2.4) Polygon Query", "_____no_output_____" ] ], [ [ "# Run Time: 35s\n\n# Setup\nbig_triangle = Polygon(\n shell=[\n (1024, 1024),\n (1024, 4096),\n (4096, 4096),\n (1024, 1024),\n ]\n)\n\n\n# Time DictionaryStore\ndict_runs = timeit.repeat(\n \"store.query(polygon)\",\n globals={\"store\": cell_dict_store, \"polygon\": big_triangle},\n number=1,\n repeat=3,\n)\n\n# Time SQLite store\nsqlite_runs = timeit.repeat(\n \"store.query(polygon)\",\n globals={\"store\": cell_sqlite_store, \"polygon\": big_triangle},\n number=1,\n repeat=3,\n)", "_____no_output_____" ], [ "# Plot results\nplot_results(\n experiments=[dict_runs, sqlite_runs],\n title=\"Polygon Query (5 Million Polygons)\",\n tick_label=[\n \"DictionaryStore\",\n \"SQLiteStore\",\n ],\n)\nplt.show()", "_____no_output_____" ] ], [ [ "### 2.2.5) Predicate Query", "_____no_output_____" ] ], [ [ "# Run Time: ~10m\n\n# Setup\nxmin, ymin, xmax, ymax = 128, 12, 256, 256\nbox = Polygon.from_bounds(xmin, ymin, xmax, ymax)\npredicate = \"props['class'] == 0\"\n\n# Time DictionaryStore\ndict_runs = timeit.repeat(\n \"store.query(box, predicate)\",\n globals={\"store\": cell_dict_store, \"box\": box, \"predicate\": predicate},\n number=1,\n repeat=3,\n)\n\n# Time SQLiteStore\nsqlite_runs = timeit.repeat(\n \"store.query(box, where=predicate)\",\n globals={\"store\": cell_sqlite_store, \"box\": box, \"predicate\": predicate},\n number=1,\n repeat=3,\n)\n\nnp_stmt = f\"\"\"\npolygons = [\n polygon\n for polygon in tqdm(cell_polygons_np)\n if np.all([np.max(polygon, 0) >= ({xmin}, {ymin}), np.min(polygon, 0) <= ({xmax}, {ymax})])\n]\n\"\"\"\n\n# Time numpy\nnumpy_runs = timeit.repeat(\n np_stmt,\n globals={\"cell_polygons_np\": cell_polygons_np, \"np\": np, \"tqdm\": lambda x: x},\n number=1,\n repeat=3,\n)\n\n# Time shapely\nshapely_runs = timeit.repeat(\n \"polygons = [box.intersects(ann.geometry) for ann in cell_polygons]\",\n globals={\"box\": box, \"cell_polygons\": cell_polygons},\n number=1,\n repeat=3,\n)\n\n# Time box indexed numpy\nnumpy_index_runs = timeit.repeat(\n \"in_box = np.all(min_max_index[:, :2] <= (xmax, ymax), 1) & np.all(min_max_index[:, 2:] >= (xmin, ymin), 1)\\n\"\n \"polygons = [p for p, w in zip(cell_polygons, in_box) if w]\",\n globals={\n \"min_max_index\": min_max_index,\n \"xmin\": xmin,\n \"ymin\": ymin,\n \"xmax\": xmax,\n \"ymax\": ymax,\n \"np\": np,\n \"cell_polygons\": cell_polygons,\n },\n number=1,\n repeat=3,\n)", "_____no_output_____" ], [ "# Run Time: ~5s \n\n# Plot results\nplot_results(\n experiments=[dict_runs, sqlite_runs, numpy_runs, shapely_runs, numpy_index_runs],\n title=\"Box Query\",\n tick_label=[\n \"DictionaryStore\",\n \"SQLiteStore\",\n \"NumPy\\n(Simple Loop)\",\n \"Shapely\\n(Simple Loop)\",\n \"NumPy\\n(With Bounds Index)\",\n ],\n)\nplt.xticks(rotation=90)\nplt.show()", "_____no_output_____" ] ], [ [ "## 2.3) Size vs Approximate Lower Bound\n\nHere we calculate an estimated lower bound on file size by finding the\nthe Shannon entropy of each file. This tells us the theoretical minimum\nnumber of bits per byte. The lowest lower bound is then used as an\nestimate of the minimum file size possible to store the annotation data.", "_____no_output_____" ] ], [ [ "# Run Time: ~5m\n\n\n# Files to consider containing keys, geometry, and properties.\n# Files which are missing keys e.g. cells.pickle are excluded\n# for a fair comparison.\nfile_names = [\n \"cells-dicionary-store.pickle\",\n \"cells-dict.pickle\",\n \"cells.db\",\n \"cells.db.zstd\",\n \"cells.geojson\",\n \"cells.ndjson\",\n \"cells.ndjson.zstd\",\n]\n\n\ndef human_readible_bytes(byte_count: int) -> Tuple[int, str]:\n \"\"\"Convert bytes to human readble size and suffix.\"\"\"\n for suffix in [\"B\", \"KB\", \"MB\", \"GB\", \"TB\"]:\n if byte_count < 1024:\n return byte_count, suffix\n byte_count /= 1024\n return byte_count, \"PB\"\n\n\ndef shannon_entropy(\n fp: Path,\n sample_size: int = 1e9, # 1GiB\n stride: int = 7,\n skip: int = 1e5, # 100KiB\n) -> float:\n \"\"\"Calculate the Shannon entropy of a file from a sample.\n\n The first `skip` bytes are skipped to avoid sampling low entropy\n (highly ordered) parts which commonly occur at the beginning e.g.\n headers.\n\n Args:\n fp: File path to calculate entropy of.\n sample_size: Number of bytes to sample from the file.\n stride: Number of bytes to skip between samples.\n skip: Number of bytes to skip before sampling.\n \"\"\"\n npmmap = np.memmap(Path(fp), dtype=np.uint8, mode=\"r\")\n values, counts = np.unique(\n npmmap[int(skip) : int(skip + (sample_size * stride)) : int(stride)],\n return_counts=True,\n )\n total = np.sum(counts)\n frequencies = {v: 0 for v in range(256)}\n for v, x in zip(values, counts):\n frequencies[v] = x / total\n frequency_array = np.array(list(frequencies.values()))\n epsilon = 1e-16\n return -np.sum(frequency_array * np.log2(frequency_array + epsilon))\n\n\n# Find the min across all of the representations for the lowest lower\n# bound.\nbytes_lower_bounds = {\n path: (\n shannon_entropy(Path(path)) / 8 * len(np.memmap(path, dtype=np.uint8, mode=\"r\"))\n )\n for path in tqdm([Path(\".\") / name for name in file_names], position=0, leave=False)\n}\n\nlowest_bytes_lower_bound = min(bytes_lower_bounds.values())\n\nsize, suffix = human_readible_bytes(lowest_bytes_lower_bound)\nprint(f\"Approximate Lower Bound Size: {size:.2f} {suffix}\")", " " ] ], [ [ "### Plot Results", "_____no_output_____" ] ], [ [ "# Get file sizes\nfile_sizes = {path: path.stat().st_size for path in [Path(\".\") / name for name in file_names]}\n\n# Sort by size\nfile_sizes = {k: v for k, v in sorted(file_sizes.items(), key=lambda x: x[1])}\n\n# Plot\nplt.bar(\n x=range(len(file_sizes)),\n height=file_sizes.values(),\n tick_label=[p.name for p in file_sizes],\n color=[f\"C{i}\" for i in range(len(file_sizes))],\n)\nplt.xlabel(\"File Name\")\nplt.ylabel(\"Bytes\")\nplt.xticks(rotation=90)\nplt.hlines(\n y=lowest_bytes_lower_bound,\n xmin=-0.5,\n xmax=len(file_sizes) - 0.5,\n linestyles=\"dashed\",\n color=\"black\",\n label=\"Approximate Bytes Lower Bound\",\n)\nplt.legend()\nplt.tight_layout()\nplt.title(\"Polygon Annotation File Sizes\")\nplt.show()", "_____no_output_____" ] ], [ [ "The SQLite representation (4.9GB) appears to be quite compact compared\nwith GeoJSON and ndjson. Although not as compact as a dictionary pickle\nor Zstandard compressed ndjson, it offers a good compromise between\ncompactness and read performance.", "_____no_output_____" ], [ "# 3: Extra Bits\n\n## 3.1) Space Saving\n\nA lot of space can be saved by rounding the coordinates to the nearest\ninteger when storing them. Below we make a copy of the dataset with all\ncoordinates rounded.", "_____no_output_____" ] ], [ [ "# Run Time: ~50m\n! rm integer-cells.db\nint_cell_sqlite_store = SQLiteStore(\"integer-cells.db\")\n\n# We use batches of 1000 to speed up appending\nbatch = {}\nfor key, annotation in tqdm(cell_sqlite_store.items(), total=len(cell_sqlite_store)):\n geometry = Polygon(np.array(annotation.geometry.exterior.coords).round())\n rounded_annotation = Annotation(geometry, annotation.properties)\n batch[key] = rounded_annotation\n if len(batch) >= 1000:\n int_cell_sqlite_store.append_many(batch.values(), batch.keys())\n batch = {}\n_ = int_cell_sqlite_store.append_many(batch.values(), batch.keys())", "100%|██████████| 10008338/10008338 [51:00<00:00, 3270.16it/s] \n" ] ], [ [ "Here the database size is reduced to 2.9GB, down from 4.9GB.\nAdditionally, when using integer coordinates, the database compresses\nmuch better. Zstandard can compress to approximately 60% of the\noriginal size (and 35% of the floating point coordinate\ndatabase size). This may be done for archival purposes.", "_____no_output_____" ] ], [ [ "# Run time: ~15s\n! zstd -f -k integer-cells.db -o integer-cells.db.zstd", "integer-cells.db : 60.58% ( 2.86 GiB => 1.73 GiB, integer-cells.db.zstd) \n" ] ], [ [ "With higher (slower) compression settings the space can be further\nreduced for long term storage.", "_____no_output_____" ] ], [ [ "# Run time: ~20m\n! zstd -f -k -19 --long integer-cells.db -o integer-cells.db.19.zstd", "integer-cells.db : 51.22% ( 2.86 GiB => 1.47 GiB, integer-cells.db.19.zstd) \n" ] ], [ [ "## 3.2) Feature Comparison Summary\n\nHere we briefly summarise some of the positives and negatives of each format and construct a comparison matrix.\n\n**GeoJSON**\n\n*Positives*\n\n+ Simple, based JSON which is well known.\n+ Well defined with a public specification.\n+ Popular format for geometry, many tools which work with it.\n+ Fast to write.\n\n*Negatives*\n\n- Requires loading the whole file into memory for parsing. Some\n specialised parsers can, in some situations, reduce or avoid this but\n it is not possible in general.\n- Not a very compact representation.\n\n**ndjson (One GeoJSON Feature Per Line)**\n\n*Positives*\n\n+ Simple.\n+ Better to parse than JSON/GeoJSON. Each line can be parsed\n independently.\n+ Many tools to parse JSON lines.\n+ Fast to write.\n\n*Negatives*\n\n- Not a very compact representation.\n- Requires loading the whole dataset from disk before querying OR\n scanning through and reparsing each line for each query.\n- Amending annotations can be tricky. The easiest way is to blank out a\n line and append a modified copy each time. This could end up\n fragmenting the file and wasting a lot of space. More complex methods\n could be developed to reduce fragmenting the file.\n\n**pickle**\n\n*Positives*\n\n+ Fast to write.\n\n*Negatives*\n\n- Vulnerable to arbitrary code execution when loading from disk.\n- Requires loading the whole dataset into memory for querying.\n\n**SQLite (SQLiteStore Flavour)**\n\n*Positives*\n\n+ Very fast to query (uses an R-TREE index to accelerate\n spatial queries).\n+ Does not require loading data into memory before querying.\n+ Possible to index property lookups.\n\n*Negatives*\n\n- Not the most compact representation on disk.\n\n### Feature Matrix\n\n| Format | Size On-Disk | Size In-Memory | Partial Reads | Serialization | Query Performance |\n|----------------:|:---------------|:---------------|:--------------|:----------------|:------------------|\n| SQLiteStore | Medium | Small | Yes | Slow | Fast |\n| GeoJSON | Large | Large | No | Fast | Slow |\n| ndjson | Large | Large | Yes | Fast | Medium |\n| pickle | Small | Medium | No | Medium | Slow |\n", "_____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", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

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

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "#### Copyright 2017 Google LLC.", "_____no_output_____" ] ], [ [ "# 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_____" ] ], [ [ "# Synthetic Features and Outliers", "_____no_output_____" ], [ "**Learning Objectives:**\n * Create a synthetic feature that is the ratio of two other features\n * Use this new feature as an input to a linear regression model\n * Improve the effectiveness of the model by identifying and clipping (removing) outliers out of the input data", "_____no_output_____" ], [ "Let's revisit our model from the previous First Steps with TensorFlow exercise. \n\nFirst, we'll import the California housing data into a *pandas* `DataFrame`:", "_____no_output_____" ], [ "## Setup", "_____no_output_____" ] ], [ [ "from __future__ import print_function\n\nimport math\n\nfrom IPython import display\nfrom matplotlib import cm\nfrom matplotlib import gridspec\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport pandas as pd\nimport sklearn.metrics as metrics\nimport tensorflow as tf\nfrom tensorflow.python.data import Dataset\n\ntf.logging.set_verbosity(tf.logging.ERROR)\npd.options.display.max_rows = 10\npd.options.display.float_format = '{:.1f}'.format\n\ncalifornia_housing_dataframe = pd.read_csv(\"https://download.mlcc.google.com/mledu-datasets/california_housing_train.csv\", sep=\",\")\n\ncalifornia_housing_dataframe = california_housing_dataframe.reindex(\n np.random.permutation(california_housing_dataframe.index))\ncalifornia_housing_dataframe[\"median_house_value\"] /= 1000.0\ncalifornia_housing_dataframe", "_____no_output_____" ] ], [ [ "Next, we'll set up our input function, and define the function for model training:", "_____no_output_____" ] ], [ [ "def my_input_fn(features, targets, batch_size=1, shuffle=True, num_epochs=None):\n \"\"\"Trains a linear regression model of one feature.\n \n Args:\n features: pandas DataFrame of features\n targets: pandas DataFrame of targets\n batch_size: Size of batches to be passed to the model\n shuffle: True or False. Whether to shuffle the data.\n num_epochs: Number of epochs for which data should be repeated. None = repeat indefinitely\n Returns:\n Tuple of (features, labels) for next data batch\n \"\"\"\n \n # Convert pandas data into a dict of np arrays.\n features = {key:np.array(value) for key,value in dict(features).items()} \n \n # Construct a dataset, and configure batching/repeating.\n ds = Dataset.from_tensor_slices((features,targets)) # warning: 2GB limit\n ds = ds.batch(batch_size).repeat(num_epochs)\n \n # Shuffle the data, if specified.\n if shuffle:\n ds = ds.shuffle(buffer_size=10000)\n \n # Return the next batch of data.\n features, labels = ds.make_one_shot_iterator().get_next()\n return features, labels", "_____no_output_____" ], [ "def train_model(learning_rate, steps, batch_size, input_feature):\n \"\"\"Trains a linear regression model.\n \n Args:\n learning_rate: A `float`, the learning rate.\n steps: A non-zero `int`, the total number of training steps. A training step\n consists of a forward and backward pass using a single batch.\n batch_size: A non-zero `int`, the batch size.\n input_feature: A `string` specifying a column from `california_housing_dataframe`\n to use as input feature.\n \n Returns:\n A Pandas `DataFrame` containing targets and the corresponding predictions done\n after training the model.\n \"\"\"\n \n periods = 10\n steps_per_period = steps / periods\n\n my_feature = input_feature\n my_feature_data = california_housing_dataframe[[my_feature]].astype('float32')\n my_label = \"median_house_value\"\n targets = california_housing_dataframe[my_label].astype('float32')\n\n # Create input functions.\n training_input_fn = lambda: my_input_fn(my_feature_data, targets, batch_size=batch_size)\n predict_training_input_fn = lambda: my_input_fn(my_feature_data, targets, num_epochs=1, shuffle=False)\n \n # Create feature columns.\n feature_columns = [tf.feature_column.numeric_column(my_feature)]\n \n # Create a linear regressor object.\n my_optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate)\n my_optimizer = tf.contrib.estimator.clip_gradients_by_norm(my_optimizer, 5.0)\n linear_regressor = tf.estimator.LinearRegressor(\n feature_columns=feature_columns,\n optimizer=my_optimizer\n )\n\n # Set up to plot the state of our model's line each period.\n plt.figure(figsize=(15, 6))\n plt.subplot(1, 2, 1)\n plt.title(\"Learned Line by Period\")\n plt.ylabel(my_label)\n plt.xlabel(my_feature)\n sample = california_housing_dataframe.sample(n=300)\n plt.scatter(sample[my_feature], sample[my_label])\n colors = [cm.coolwarm(x) for x in np.linspace(-1, 1, periods)]\n\n # Train the model, but do so inside a loop so that we can periodically assess\n # loss metrics.\n print(\"Training model...\")\n print(\"RMSE (on training data):\")\n root_mean_squared_errors = []\n for period in range (0, periods):\n # Train the model, starting from the prior state.\n linear_regressor.train(\n input_fn=training_input_fn,\n steps=steps_per_period,\n )\n # Take a break and compute predictions.\n predictions = linear_regressor.predict(input_fn=predict_training_input_fn)\n predictions = np.array([item['predictions'][0] for item in predictions])\n \n # Compute loss.\n root_mean_squared_error = math.sqrt(\n metrics.mean_squared_error(predictions, targets))\n # Occasionally print the current loss.\n print(\" period %02d : %0.2f\" % (period, root_mean_squared_error))\n # Add the loss metrics from this period to our list.\n root_mean_squared_errors.append(root_mean_squared_error)\n # Finally, track the weights and biases over time.\n # Apply some math to ensure that the data and line are plotted neatly.\n y_extents = np.array([0, sample[my_label].max()])\n \n weight = linear_regressor.get_variable_value('linear/linear_model/%s/weights' % input_feature)[0]\n bias = linear_regressor.get_variable_value('linear/linear_model/bias_weights')\n \n x_extents = (y_extents - bias) / weight\n x_extents = np.maximum(np.minimum(x_extents,\n sample[my_feature].max()),\n sample[my_feature].min())\n y_extents = weight * x_extents + bias\n plt.plot(x_extents, y_extents, color=colors[period]) \n print(\"Model training finished.\")\n\n # Output a graph of loss metrics over periods.\n plt.subplot(1, 2, 2)\n plt.ylabel('RMSE')\n plt.xlabel('Periods')\n plt.title(\"Root Mean Squared Error vs. Periods\")\n plt.tight_layout()\n plt.plot(root_mean_squared_errors)\n\n # Create a table with calibration data.\n calibration_data = pd.DataFrame()\n calibration_data[\"predictions\"] = pd.Series(predictions)\n calibration_data[\"targets\"] = pd.Series(targets)\n display.display(calibration_data.describe())\n\n print(\"Final RMSE (on training data): %0.2f\" % root_mean_squared_error)\n \n return calibration_data", "_____no_output_____" ] ], [ [ "## Task 1: Try a Synthetic Feature\n\nBoth the `total_rooms` and `population` features count totals for a given city block.\n\nBut what if one city block were more densely populated than another? We can explore how block density relates to median house value by creating a synthetic feature that's a ratio of `total_rooms` and `population`.\n\nIn the cell below, create a feature called `rooms_per_person`, and use that as the `input_feature` to `train_model()`.\n\nWhat's the best performance you can get with this single feature by tweaking the learning rate? (The better the performance, the better your regression line should fit the data, and the lower\nthe final RMSE should be.)", "_____no_output_____" ], [ "**NOTE**: You may find it helpful to add a few code cells below so you can try out several different learning rates and compare the results. To add a new code cell, hover your cursor directly below the center of this cell, and click **CODE**.", "_____no_output_____" ] ], [ [ "#\n# YOUR CODE HERE\n#\ncalifornia_housing_dataframe[\"rooms_per_person\"] =\n\ncalibration_data = train_model(\n learning_rate=0.00005,\n steps=500,\n batch_size=5,\n input_feature=\"rooms_per_person\"\n)", "_____no_output_____" ] ], [ [ "### Solution\n\nClick below for a solution.", "_____no_output_____" ] ], [ [ "california_housing_dataframe[\"rooms_per_person\"] = (\n california_housing_dataframe[\"total_rooms\"] / california_housing_dataframe[\"population\"])\n\ncalibration_data = train_model(\n learning_rate=0.05,\n steps=500,\n batch_size=5,\n input_feature=\"rooms_per_person\")", "_____no_output_____" ] ], [ [ "## Task 2: Identify Outliers\n\nWe can visualize the performance of our model by creating a scatter plot of predictions vs. target values. Ideally, these would lie on a perfectly correlated diagonal line.\n\nUse Pyplot's [`scatter()`](https://matplotlib.org/gallery/shapes_and_collections/scatter.html) to create a scatter plot of predictions vs. targets, using the rooms-per-person model you trained in Task 1.\n\nDo you see any oddities? Trace these back to the source data by looking at the distribution of values in `rooms_per_person`.", "_____no_output_____" ] ], [ [ "# YOUR CODE HERE", "_____no_output_____" ] ], [ [ "### Solution\n\nClick below for the solution.", "_____no_output_____" ] ], [ [ "plt.figure(figsize=(15, 6))\nplt.subplot(1, 2, 1)\nplt.scatter(calibration_data[\"predictions\"], calibration_data[\"targets\"])", "_____no_output_____" ] ], [ [ "The calibration data shows most scatter points aligned to a line. The line is almost vertical, but we'll come back to that later. Right now let's focus on the ones that deviate from the line. We notice that they are relatively few in number.\n\nIf we plot a histogram of `rooms_per_person`, we find that we have a few outliers in our input data:", "_____no_output_____" ] ], [ [ "plt.subplot(1, 2, 2)\n_ = california_housing_dataframe[\"rooms_per_person\"].hist()", "_____no_output_____" ] ], [ [ "## Task 3: Clip Outliers\n\nSee if you can further improve the model fit by setting the outlier values of `rooms_per_person` to some reasonable minimum or maximum.\n\nFor reference, here's a quick example of how to apply a function to a Pandas `Series`:\n\n clipped_feature = my_dataframe[\"my_feature_name\"].apply(lambda x: max(x, 0))\n\nThe above `clipped_feature` will have no values less than `0`.", "_____no_output_____" ] ], [ [ "# YOUR CODE HERE", "_____no_output_____" ] ], [ [ "### Solution\n\nClick below for the solution.", "_____no_output_____" ], [ "The histogram we created in Task 2 shows that the majority of values are less than `5`. Let's clip `rooms_per_person` to 5, and plot a histogram to double-check the results.", "_____no_output_____" ] ], [ [ "california_housing_dataframe[\"rooms_per_person\"] = (\n california_housing_dataframe[\"rooms_per_person\"]).apply(lambda x: min(x, 5))\n\n_ = california_housing_dataframe[\"rooms_per_person\"].hist()", "_____no_output_____" ] ], [ [ "To verify that clipping worked, let's train again and print the calibration data once more:", "_____no_output_____" ] ], [ [ "calibration_data = train_model(\n learning_rate=0.05,\n steps=500,\n batch_size=5,\n input_feature=\"rooms_per_person\")", "_____no_output_____" ], [ "_ = plt.scatter(calibration_data[\"predictions\"], calibration_data[\"targets\"])", "_____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", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import datetime, time\nimport platform\nimport simpy\nimport shapely.geometry\nfrom simplekml import Kml, Style\nimport numpy as np\n\nimport halem.Base_functions as halem\nimport halem.Mesh_maker as Mesh_maker\nimport halem.Functions as Functions\nimport halem.Calc_path as Calc_path\n\nimport pickle\nimport networkx as nx\n\nimport matplotlib.pyplot as plt\nplt.style.use('ggplot')\nfrom cartopy import config\nimport cartopy.crs as ccrs\nimport cartopy.feature as cfeature\nfrom matplotlib.collections import LineCollection\nfrom matplotlib.colors import ListedColormap, BoundaryNorm\nfrom scipy.interpolate import griddata\n\nimport netCDF4\nfrom netCDF4 import Dataset, num2date\nfrom scipy.spatial import Delaunay\nfrom shapely.geometry import Point\nfrom shapely.geometry.polygon import Polygon\n\ndef scale_bar_left(ax, bars=4, length=4, location=(0.1, 0.05), linewidth=3, col='black'):\n \"\"\"\n ax is the axes to draw the scalebar on.\n bars is the number of subdivisions of the bar (black and white chunks)\n length is the length of the scalebar in km.\n location is left side of the scalebar in axis coordinates.\n (ie. 0 is the left side of the plot)\n linewidth is the thickness of the scalebar.\n color is the color of the scale bar\n \"\"\"\n # Get the limits of the axis in lat long\n llx0, llx1, lly0, lly1 = ax.get_extent(ccrs.PlateCarree())\n # Make tmc aligned to the left of the map,\n # vertically at scale bar location\n sbllx = llx0 + (llx1 - llx0) * location[0]\n sblly = lly0 + (lly1 - lly0) * location[1]\n tmc = ccrs.TransverseMercator(sbllx, sblly)\n # Get the extent of the plotted area in coordinates in metres\n x0, x1, y0, y1 = ax.get_extent(tmc)\n # Turn the specified scalebar location into coordinates in metres\n sbx = x0 + (x1 - x0) * location[0]\n sby = y0 + (y1 - y0) * location[1]\n\n # Calculate a scale bar length if none has been given\n # (Theres probably a more pythonic way of rounding the number but this works)\n if not length:\n length = (x1 - x0) / 5000 # in km\n ndim = int(np.floor(np.log10(length))) # number of digits in number\n length = round(length, -ndim) # round to 1sf\n\n # Returns numbers starting with the list\n def scale_number(x):\n if str(x)[0] in ['1', '2', '5']:\n return int(x)\n else:\n return scale_number(x - 10 ** ndim)\n\n length = scale_number(length)\n\n # Generate the x coordinate for the ends of the scalebar\n bar_xs = [sbx, sbx + length * 1000 / bars]\n # Plot the scalebar chunks\n barcol = 'white'\n for i in range(0, bars):\n # plot the chunk\n ax.plot(bar_xs, [sby, sby], transform=tmc, color=barcol, linewidth=linewidth)\n # alternate the colour\n if barcol == 'white':\n barcol = 'dimgrey'\n else:\n barcol = 'white'\n # Generate the x coordinate for the number\n bar_xt = sbx + i * length * 1000 / bars\n # Plot the scalebar label for that chunk\n ax.text(bar_xt, sby, str(round(i * length / bars)), transform=tmc,\n horizontalalignment='center', verticalalignment='bottom',\n color=col)\n # work out the position of the next chunk of the bar\n bar_xs[0] = bar_xs[1]\n bar_xs[1] = bar_xs[1] + length * 1000 / bars\n # Generate the x coordinate for the last number\n bar_xt = sbx + length * 1000\n # Plot the last scalebar label\n ax.text(bar_xt, sby, str(round(length)), transform=tmc,\n horizontalalignment='center', verticalalignment='bottom',\n color=col)\n # Plot the unit label below the bar\n bar_xt = sbx + length * 1000 / 2\n bar_yt = y0 + (y1 - y0) * (location[1] / 4)\n ax.text(bar_xt, bar_yt, 'km', transform=tmc, horizontalalignment='center',\n verticalalignment='bottom', color=col)", "_____no_output_____" ], [ "coords_WGS = np.loadtxt('E:/Use_case_Schouwen/baty_WGS.csv') \n\nload_factor =np.array([0]) # Roadmap11\n \nstart = [3.674, 51.70969009] # Location of the koppelpunt (lon, lat)\nstop = [3.522637481591586,51.76880095558772] # Location of the dredging area (lon, lat)\nVolume = 425_500 # Total volume to be dregded (m^3)\n\nunloading_rate = 1.5\nloading_rate = 1.5\nukc = 1.0 # Under Keel clearance (m)\nWWL = 20 # Width on Water Line (m)\nLWL = 80 # Length on Water Line (m)\nhopper_capacity = 4000 # Maximal capacity of the hopper (m^3)\nV_full = 10*0.514444444 # Velocity in deep water when maximal loaded (m/s)\nV_emp = 12*0.514444444 # Maximal sailing velocity empty in deep water (m/s)\nT_full = 6.5 # Draft when maximal Loaded (m)\nT_emp = 3.5 # Draft When empty (m)\nWVPI_full = 10000 # Weight when maximal loaded (tf)\nWVPI_empt = 4000 # Weight empty (tf)\n\nvship = [[V_emp]]", "_____no_output_____" ], [ "files = [\n '01_DCSM-FM_100m/Roadmap11SIM',\n '02_DCSM-FM_100m NB3/Roadmap11SIM',\n '03_Zuno_real_data/Roadmap11SIM',\n '03_Zuno_real_data NB3/Roadmap11SIM'\n]\n\nPaths = []\ntime_paths = []\ndistances = []\n\nfor name_textfile_load in files:\n print('done')\n with open(name_textfile_load, 'rb') as input:\n Roadmap = pickle.load(input)\n\n\n\n ind = halem.Calc_path.Has_route.find_startstop(None, start[::-1], Roadmap.nodes)\n ind = np.argwhere(Roadmap.WD[ind,:] == Roadmap.WD[ind,75:125].max())[0][0]\n print(Roadmap.WD[ind,75:125].max(), name_textfile_load)\n t0 = datetime.datetime.fromtimestamp(Roadmap.t[ind]+12).strftime('%d/%m/%Y %H:%M:%S')\n\n Path, timePath, dist = halem.HALEM_time(start,\n stop,\n t0 ,\n vship[0][0],\n Roadmap\n )\n\n Paths.append(Path)\n time_paths.append(timePath)\n distances.append(dist)\n\n\n ind = halem.Calc_path.Has_route.find_startstop(None, start[::-1], Roadmap.nodes)\n ind = np.argwhere(Roadmap.WD[ind,:] == Roadmap.WD[ind,:].min())[0][0]\n print(Roadmap.WD[ind,75:125].min(), name_textfile_load)\n t1 = datetime.datetime.fromtimestamp(Roadmap.t[ind]).strftime('%d/%m/%Y %H:%M:%S')\n\n Path2, timePath2, dist2 = halem.HALEM_time(start, \n stop,\n t1 ,\n vship[0][0],\n Roadmap\n )\n Paths.append(Path2)\n time_paths.append(timePath2)\n distances.append(dist2)\n", "done\n16.819456392313686 01_DCSM-FM_100m/Roadmap11SIM\n6.766525443656578 01_DCSM-FM_100m/Roadmap11SIM\ndone\n16.819456392313686 02_DCSM-FM_100m NB3/Roadmap11SIM\n6.766525443656578 02_DCSM-FM_100m NB3/Roadmap11SIM\ndone\n12.861028989796681 03_Zuno_real_data/Roadmap11SIM\n13.398964103121996 03_Zuno_real_data/Roadmap11SIM\ndone\n12.861028989796681 03_Zuno_real_data NB3/Roadmap11SIM\n13.398964103121996 03_Zuno_real_data NB3/Roadmap11SIM\n" ], [ "# -----------------------------------------------------------------------------\n# -----------------------------------------------------------------------------\n# Plot Background\n# -----------------------------------------------------------------------------\n# -----------------------------------------------------------------------------\n\nD_emp = 4.0\nD_full = 8.0\nukc = 1.0\ntide = -1.3\n\nN = 100\nx_r = np.arange(coords_WGS[:,0].min(), coords_WGS[:,0].max(), (coords_WGS[:,0].max() - coords_WGS[:,0].min())/N)\ny_r = np.arange(coords_WGS[:,1].min(), coords_WGS[:,1].max(), (coords_WGS[:,1].max() - coords_WGS[:,1].min())/N)\ny_r, x_r = np.meshgrid(y_r,x_r)\n\nWD_r = tide - griddata(coords_WGS[:,:2], coords_WGS[:,2], (x_r, y_r), method= 'linear')\nWD_r[np.isnan(WD_r)] = 0\nWD_r[WD_r<-1000] = 0\ncval = [-1000,D_emp + ukc -3.3, D_emp +ukc, D_full+ukc, 100]\ncval2 = [D_emp + ukc - 3.3, D_emp +ukc, D_full+ukc]\n\nfig = plt.figure(figsize = (20,20))\n\nax = plt.subplot(projection=ccrs.Mercator())\nim = plt.contourf(x_r,y_r,WD_r,cval,\n transform=ccrs.PlateCarree(), \n colors = ('tab:red','sandybrown', 'cornflowerblue', 'darkblue'),\n alpha = 0.75\n )\nplt.contour(x_r,y_r,WD_r,cval2,transform=ccrs.PlateCarree(), colors = 'black')\nax.add_feature(cfeature.NaturalEarthFeature('physical', 'land', '10m', edgecolor='face', facecolor='palegoldenrod'))\nax.coastlines(resolution='10m', color='darkgoldenrod', linewidth=3)\nax.gridlines(color = 'grey', zorder = 3)\nax.set_extent([coords_WGS[:,0].min(),coords_WGS[:,0].max(),coords_WGS[:,1].min()*1.0015,coords_WGS[:,1].max()*0.998])\n\n# -----------------------------------------------------------------------------\n# -----------------------------------------------------------------------------\n# Calclate different routes \n# -----------------------------------------------------------------------------\n# Calculation at HHW and at LLW for a empty shipt from nourishment to dredging area\n# -----------------------------------------------------------------------------\n\nlabels = [\n 'FM model nb = 1 at HW',\n 'FM model nb = 1 at LW',\n 'FM model nb = 3 at HW',\n 'FM model nb = 3 at LW',\n 'Zuno model nb = 1 at HW',\n 'Zuno model nb = 1 at LW',\n 'Zuno model nb = 3 at HW',\n 'Zuno model nb = 3 at LW',\n \n]\n\ncolors = [\n 'k',\n 'tab:grey',\n 'lightgrey',\n 'darkgrey',\n \n 'tab:red',\n 'darkred',\n 'pink',\n 'coral'\n]\n\n\nfor i, Path in enumerate(Paths):\n plt.plot(Path[:,0],\n Path[:,1],\n transform=ccrs.PlateCarree(),\n linewidth =5,\n markersize = 3,\n label = labels[i],\n color = colors[i]\n )\n \n\nax.legend(prop={'size': 15})\n\nscale_bar_left(ax)\n\nplt.plot(start[0], \n start[1],\n 'o',\n color = 'tab:green',\n transform=ccrs.PlateCarree(), \n label = 'Nourishment location', \n markersize = 15\n )\n\nplt.plot(stop[0], \n stop[1], \n 'o',color = 'tab:purple',\n transform=ccrs.PlateCarree() , \n label = 'Mining location', \n markersize = 15\n )\n\nfig.savefig('Sinlge_route_optimisation.svg')\nfig.savefig('Sinlge_route_optimisation')\nplt.show()", "_____no_output_____" ], [ "fig = plt.figure(figsize=(10,10))\nfor i in range(8):\n plt.plot(\n (time_paths[i][:-1] - time_paths[i][0]) / 3600,\n distances[i]/1000, \n label = labels[i],\n color = colors[i]\n )\n\nplt.legend()", "_____no_output_____" ] ] ]

[ "code" ]

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

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# GAN Workflow Engine with the MedNIST Dataset\n\nThe MONAI framework can be used to easily design, train, and evaluate generative adversarial networks.\nThis notebook exemplifies using MONAI components to design and train a simple GAN model to reconstruct images of Hand CT scans.\n\nRead the [MONAI Mednist GAN Tutorial](https://github.com/Project-MONAI/MONAI/blob/master/examples/notebooks/mednist_GAN_tutorial.ipynb) for details about the network architecture and loss functions.\n\n**Table of Contents**\n\n1. Setup\n2. Initialize MONAI Components\n * Create image transform chain\n * Create dataset and dataloader\n * Define generator and discriminator\n * Create training handlers\n * Create GanTrainer\n3. Run Training\n4. Evaluate Results\n\n[](https://colab.research.google.com/github/Project-MONAI/MONAI/blob/master/examples/notebooks/mednist_GAN_workflow.ipynb)", "_____no_output_____" ], [ "## Step 1: Setup\n\n### Setup environment", "_____no_output_____" ] ], [ [ "%pip install -qU \"monai[ignite]\"", "Note: you may need to restart the kernel to use updated packages.\n" ], [ "# temporarily need this, FIXME remove when d93c0a6 released\n%pip install -qU git+https://github.com/Project-MONAI/MONAI#egg=MONAI", "Note: you may need to restart the kernel to use updated packages.\n" ], [ "%pip install -qU matplotlib\n%matplotlib inline", "Note: you may need to restart the kernel to use updated packages.\n" ] ], [ [ "### Setup imports", "_____no_output_____" ] ], [ [ "import logging\nimport os\nimport shutil\nimport sys\nimport tempfile\n\nimport IPython\nimport matplotlib.pyplot as plt\nimport torch\n\nfrom monai.apps import download_and_extract\nfrom monai.config import print_config\nfrom monai.data import CacheDataset, DataLoader\nfrom monai.engines import GanKeys, GanTrainer, default_make_latent\nfrom monai.handlers import CheckpointSaver, MetricLogger, StatsHandler\nfrom monai.networks import normal_init\nfrom monai.networks.nets import Discriminator, Generator\nfrom monai.transforms import (\n AddChannelD,\n Compose,\n LoadPNGD,\n RandFlipD,\n RandRotateD,\n RandZoomD,\n ScaleIntensityD,\n ToTensorD,\n)\nfrom monai.utils import set_determinism\n\nprint_config()", "MONAI version: 0.2.0+74.g8e5a53e\nPython version: 3.7.5 (default, Nov 7 2019, 10:50:52) [GCC 8.3.0]\nNumpy version: 1.19.1\nPytorch version: 1.6.0\n\nOptional dependencies:\nPytorch Ignite version: 0.3.0\nNibabel version: NOT INSTALLED or UNKNOWN VERSION.\nscikit-image version: NOT INSTALLED or UNKNOWN VERSION.\nPillow version: 7.2.0\nTensorboard version: NOT INSTALLED or UNKNOWN VERSION.\n\nFor details about installing the optional dependencies, please visit:\n https://docs.monai.io/en/latest/installation.html#installing-the-recommended-dependencies\n\n" ] ], [ [ "### Setup data directory\n\nYou can specify a directory with the `MONAI_DATA_DIRECTORY` environment variable. \nThis allows you to save results and reuse downloads. \nIf not specified a temporary directory will be used.", "_____no_output_____" ] ], [ [ "directory = os.environ.get(\"MONAI_DATA_DIRECTORY\")\nroot_dir = tempfile.mkdtemp() if directory is None else directory\nprint(root_dir)", "/home/bengorman/notebooks/\n" ] ], [ [ "### Download dataset\n\nDownloads and extracts the dataset.\n\nThe MedNIST dataset was gathered from several sets from [TCIA](https://wiki.cancerimagingarchive.net/display/Public/Data+Usage+Policies+and+Restrictions),\n[the RSNA Bone Age Challenge](http://rsnachallenges.cloudapp.net/competitions/4),\nand [the NIH Chest X-ray dataset](https://cloud.google.com/healthcare/docs/resources/public-datasets/nih-chest).\n\nThe dataset is kindly made available by [Dr. Bradley J. Erickson M.D., Ph.D.](https://www.mayo.edu/research/labs/radiology-informatics/overview) (Department of Radiology, Mayo Clinic)\nunder the Creative Commons [CC BY-SA 4.0 license](https://creativecommons.org/licenses/by-sa/4.0/).\n\n\nIf you use the MedNIST dataset, please acknowledge the source, e.g. \nhttps://github.com/Project-MONAI/MONAI/blob/master/examples/notebooks/mednist_tutorial.ipynb.", "_____no_output_____" ] ], [ [ "resource = \"https://www.dropbox.com/s/5wwskxctvcxiuea/MedNIST.tar.gz?dl=1\"\nmd5 = \"0bc7306e7427e00ad1c5526a6677552d\"\n\ncompressed_file = os.path.join(root_dir, \"MedNIST.tar.gz\")\ndata_dir = os.path.join(root_dir, \"MedNIST\")\n\ndownload_and_extract(resource, compressed_file, root_dir, md5)", "file /home/bengorman/notebooks/MedNIST.tar.gz exists, skip downloading.\nextracted file /home/bengorman/notebooks/MedNIST exists, skip extracting.\n" ], [ "hand_dir = os.path.join(data_dir, \"Hand\")\ntraining_datadict = [\n {\"hand\": os.path.join(hand_dir, filename)} for filename in os.listdir(hand_dir)\n]", "_____no_output_____" ], [ "print(training_datadict[:5])", "[{'hand': '/home/bengorman/notebooks/MedNIST/Hand/003676.jpeg'}, {'hand': '/home/bengorman/notebooks/MedNIST/Hand/006548.jpeg'}, {'hand': '/home/bengorman/notebooks/MedNIST/Hand/002169.jpeg'}, {'hand': '/home/bengorman/notebooks/MedNIST/Hand/004081.jpeg'}, {'hand': '/home/bengorman/notebooks/MedNIST/Hand/004815.jpeg'}]\n" ] ], [ [ "## Step 2: Initialize MONAI components", "_____no_output_____" ] ], [ [ "logging.basicConfig(stream=sys.stdout, level=logging.INFO)\nset_determinism(0)\ndevice = torch.device(\"cuda:0\")", "_____no_output_____" ] ], [ [ "### Create image transform chain\n\nDefine the processing pipeline to convert saved disk images into usable Tensors.", "_____no_output_____" ] ], [ [ "train_transforms = Compose(\n [\n LoadPNGD(keys=[\"hand\"]),\n AddChannelD(keys=[\"hand\"]),\n ScaleIntensityD(keys=[\"hand\"]),\n RandRotateD(keys=[\"hand\"], range_x=15, prob=0.5, keep_size=True),\n RandFlipD(keys=[\"hand\"], spatial_axis=0, prob=0.5),\n RandZoomD(keys=[\"hand\"], min_zoom=0.9, max_zoom=1.1, prob=0.5),\n ToTensorD(keys=[\"hand\"]),\n ]\n)", "_____no_output_____" ] ], [ [ "### Create dataset and dataloader\n\nHold data and present batches during training.", "_____no_output_____" ] ], [ [ "real_dataset = CacheDataset(training_datadict, train_transforms)", "10000/10000 Load and cache transformed data: [==============================]\n" ], [ "batch_size = 300\nreal_dataloader = DataLoader(real_dataset, batch_size=batch_size, shuffle=True, num_workers=10)\n\n\ndef prepare_batch(batchdata):\n return batchdata[\"hand\"]", "_____no_output_____" ] ], [ [ "### Define generator and discriminator\n\nLoad basic computer vision GAN networks from libraries.", "_____no_output_____" ] ], [ [ "# define networks\ndisc_net = Discriminator(\n in_shape=(1, 64, 64),\n channels=(8, 16, 32, 64, 1),\n strides=(2, 2, 2, 2, 1),\n num_res_units=1,\n kernel_size=5,\n).to(device)\n\nlatent_size = 64\ngen_net = Generator(\n latent_shape=latent_size,\n start_shape=(latent_size, 8, 8),\n channels=[32, 16, 8, 1],\n strides=[2, 2, 2, 1],\n)\ngen_net.conv.add_module(\"activation\", torch.nn.Sigmoid())\ngen_net = gen_net.to(device)\n\n# initialize both networks\ndisc_net.apply(normal_init)\ngen_net.apply(normal_init)\n\n# define optimizors\nlearning_rate = 2e-4\nbetas = (0.5, 0.999)\ndisc_opt = torch.optim.Adam(disc_net.parameters(), learning_rate, betas=betas)\ngen_opt = torch.optim.Adam(gen_net.parameters(), learning_rate, betas=betas)\n\n# define loss functions\ndisc_loss_criterion = torch.nn.BCELoss()\ngen_loss_criterion = torch.nn.BCELoss()\nreal_label = 1\nfake_label = 0\n\n\ndef discriminator_loss(gen_images, real_images):\n real = real_images.new_full((real_images.shape[0], 1), real_label)\n gen = gen_images.new_full((gen_images.shape[0], 1), fake_label)\n\n realloss = disc_loss_criterion(disc_net(real_images), real)\n genloss = disc_loss_criterion(disc_net(gen_images.detach()), gen)\n\n return (genloss + realloss) / 2\n\n\ndef generator_loss(gen_images):\n output = disc_net(gen_images)\n cats = output.new_full(output.shape, real_label)\n return gen_loss_criterion(output, cats)", "_____no_output_____" ] ], [ [ "### Create training handlers\n\nPerform operations during model training.", "_____no_output_____" ] ], [ [ "metric_logger = MetricLogger(\n loss_transform=lambda x: {GanKeys.GLOSS: x[GanKeys.GLOSS], GanKeys.DLOSS: x[GanKeys.DLOSS]},\n metric_transform=lambda x: x,\n)\n\nhandlers = [\n StatsHandler(\n name=\"batch_training_loss\",\n output_transform=lambda x: {\n GanKeys.GLOSS: x[GanKeys.GLOSS],\n GanKeys.DLOSS: x[GanKeys.DLOSS],\n },\n ),\n CheckpointSaver(\n save_dir=os.path.join(root_dir, \"hand-gan\"),\n save_dict={\"g_net\": gen_net, \"d_net\": disc_net},\n save_interval=10,\n save_final=True,\n epoch_level=True,\n ),\n metric_logger,\n]", "_____no_output_____" ] ], [ [ "### Create GanTrainer\n\nMONAI Workflow engine for adversarial learning. The components come together here with the GanTrainer.\n\nUses a training loop based on Goodfellow et al. 2014 https://arxiv.org/abs/1406.266. \n\n```\nTraining Loop: for each batch of data size m\n 1. Generate m fakes from random latent codes.\n 2. Update D with these fakes and current batch reals, repeated d_train_steps times.\n 3. Generate m fakes from new random latent codes.\n 4. Update generator with these fakes using discriminator feedback.\n```", "_____no_output_____" ] ], [ [ "disc_train_steps = 5\nnum_epochs = 50\n\ntrainer = GanTrainer(\n device,\n num_epochs,\n real_dataloader,\n gen_net,\n gen_opt,\n generator_loss,\n disc_net,\n disc_opt,\n discriminator_loss,\n d_prepare_batch=prepare_batch,\n d_train_steps=disc_train_steps,\n g_update_latents=True,\n latent_shape=latent_size,\n key_train_metric=None,\n train_handlers=handlers,\n)", "_____no_output_____" ] ], [ [ "## Step 3: Start Training", "_____no_output_____" ] ], [ [ "trainer.run()\nIPython.display.clear_output()", "_____no_output_____" ] ], [ [ "## Evaluate Results\n\nExamine G and D loss curves for collapse.", "_____no_output_____" ] ], [ [ "g_loss = [loss[GanKeys.GLOSS] for loss in metric_logger.loss]\nd_loss = [loss[GanKeys.DLOSS] for loss in metric_logger.loss]", "_____no_output_____" ], [ "plt.figure(figsize=(12, 5))\nplt.semilogy(g_loss, label=\"Generator Loss\")\nplt.semilogy(d_loss, label=\"Discriminator Loss\")\nplt.grid(True, \"both\", \"both\")\nplt.legend()\nplt.show()", "_____no_output_____" ] ], [ [ "### View image reconstructions\nWith random latent codes view trained generator output.", "_____no_output_____" ] ], [ [ "test_img_count = 10\ntest_latents = default_make_latent(test_img_count, latent_size).to(device)\nfakes = gen_net(test_latents)\n\nfig, axs = plt.subplots(2, (test_img_count // 2), figsize=(20, 8))\naxs = axs.flatten()\nfor i, ax in enumerate(axs):\n ax.axis(\"off\")\n ax.imshow(fakes[i, 0].cpu().data.numpy(), cmap=\"gray\")", "_____no_output_____" ] ], [ [ "### Cleanup data directory\n\nRemove directory if a temporary was used.", "_____no_output_____" ] ], [ [ "if directory is None:\n shutil.rmtree(root_dir)", "_____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", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ "BSD-3-Clause" ]

[ [ [ "We show how to translate from syntax trees, to pregroup parsing diagrams, to equivalent diagrams where all cups and caps are removed.", "_____no_output_____" ] ], [ [ "from discopy import Ty, Id, Box, Diagram, Word\n\n# POS TAGS:\ns, n, adj, v, vp = Ty('S'), Ty('N'), Ty('ADJ'), Ty('V'), Ty('VP')\n\n# WORDS:\nJane = Word('Jane', n)\nloves = Word('loves', v)\nfunny = Word('funny', adj)\nboys = Word('boys', n)\n\nvocab = [Jane, loves, funny, boys]", "_____no_output_____" ] ], [ [ "## Syntax trees", "_____no_output_____" ] ], [ [ "# The CFG's production rules are boxes.\n\nR0 = Box('R0', vp @ n, s)\nR1 = Box('R1', n @ vp, s)\nR2 = Box('R2', n @ v , vp)\nR3 = Box('R3', v @ n , vp)\nR4 = Box('R4', adj @ n, n)\n\n# A syntax tree is a diagram!\n\ntree0 = R2 @ R4 >> R0\ntree1 = Id(n @ v) @ R4 >> Id(n) @ R3 >> R1\nsentence0 = Jane @ loves @ funny @ boys >> tree0\nsentence1 = Jane @ loves @ funny @ boys >> tree1\nprint(\"Two syntax trees for sentence 'Jane loves funny boys':\")\nsentence0.draw(aspect='auto')\nsentence1.draw(aspect='auto')", "Two syntax trees for sentence 'Jane loves funny boys':\n" ] ], [ [ "## Pregroup parsing", "_____no_output_____" ] ], [ [ "from discopy.rigid import Cup, Cap, Functor\n\n# Dict from POS tags to Pregroup types:\nob = {n : n, s: s, adj: n @ n.l, v: n.r @ s @ n.l, vp: s @ n.l}\n\n_Jane = Word('Jane', n)\n_loves = Word('loves', n.r @ s @ n.l)\n_funny = Word('funny', n @ n.l)\n_boys = Word('boys', n)\n\n# Dict from CFG rules to Pregroup reductions: \nar = {R0: Id(s) @ Cup(n.l, n), \n R2: Cup(n, n.r) @ Id(s @ n.l),\n R4: Id(n) @ Cup(n.l, n),\n R3: Id(n.r @ s) @ Cup(n.l, n),\n R1: Cup(n, n.r) @ Id(s),\n Jane: _Jane, loves: _loves, funny: _funny, boys: _boys}\n \nT2P = Functor(ob, ar)\nprint(\"The syntax trees are mapped to pregroup diagrams, equivalent up to interchanger:\")\nT2P(sentence0).draw(aspect='auto')\nT2P(sentence1).draw(aspect='auto')", "The syntax trees are mapped to pregroup diagrams, equivalent up to interchanger:\n" ], [ "# Check that the two diagrams above are equal up to monoidal.normal_form()\n\nassert T2P(sentence0).normal_form() == T2P(sentence0).normal_form()", "_____no_output_____" ] ], [ [ "## Snake removal", "_____no_output_____" ] ], [ [ "# Define the Wiring functor that decomposes a word into monoidal boxes with inputs transposed:\n\nlove_box = Box('loves', n @ n, s)\nfunny_box = Box('funny', n, n)\n\nob = {n: n, s: s}\nar = {_Jane: _Jane, _boys: _boys,\n _loves: Cap(n.r, n) @ Cap(n, n.l) >> Diagram.id(n.r) @ love_box @ Diagram.id(n.l), \n _funny: Cap(n, n.l) >> funny_box @ Id(n.l)}\n\nW = Functor(ob, ar)\nprint('Image of the wiring functor:')\nW(T2P(sentence0)).draw(aspect='auto')", "Image of the wiring functor:\n" ], [ "rewrite_steps = W(T2P(sentence0)).normalize()\nprint(\"Equivalent diagram for 'Jane loves funny boys', after snake removal:\")\nT2P(sentence0).to_gif(*rewrite_steps, path='../docs/imgs/jane_boys.gif', aspect='auto')", "Equivalent diagram for 'Jane loves funny boys', after snake removal:\n" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/Gan4x4/CV-HSE2019/blob/master/KNN_demo.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ] ], [ [ "# Download and unpack archive with CIFAR10 dataset to disk from official site: https://www.cs.toronto.edu/~kriz/cifar.html\n\n!wget https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\n!tar -xzf cifar-10-python.tar.gz\n!ls -l", "--2021-02-07 16:28:58-- https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz\nResolving www.cs.toronto.edu (www.cs.toronto.edu)... 128.100.3.30\nConnecting to www.cs.toronto.edu (www.cs.toronto.edu)|128.100.3.30|:443... connected.\nHTTP request sent, awaiting response... 200 OK\nLength: 170498071 (163M) [application/x-gzip]\nSaving to: ‘cifar-10-python.tar.gz’\n\ncifar-10-python.tar 100%[===================>] 162.60M 31.2MB/s in 5.8s \n\n2021-02-07 16:29:05 (27.9 MB/s) - ‘cifar-10-python.tar.gz’ saved [170498071/170498071]\n\ntotal 166516\ndrwxr-xr-x 2 2156 1103 4096 Jun 4 2009 cifar-10-batches-py\n-rw-r--r-- 1 root root 170498071 Jun 4 2009 cifar-10-python.tar.gz\ndrwxr-xr-x 1 root root 4096 Feb 4 15:26 sample_data\n" ], [ "# Loading CIFAR10 data using code from official site: https://www.cs.toronto.edu/~kriz/cifar.html\nimport numpy as np\nimport random\n\ndef unpickle(file,encoding = 'bytes'):\n import pickle\n with open(file, 'rb') as fo:\n dict = pickle.load(fo, encoding=encoding)\n return dict\n\ndef load_train_data():\n x = np.zeros((0,3072),dtype=int) # To avoid overflow \n y = np.array([],dtype=int)\n for i in range(1,6):\n raw = unpickle(f\"/content/cifar-10-batches-py/data_batch_{i}\")\n x = np.append(x,np.array(raw[b'data'],dtype=int),axis=0)\n y = np.append(y,np.array(raw[b'labels'],dtype=int),axis=0)\n return x,y\n\nx_train, y_train = load_train_data()\n\ntest = unpickle(\"/content/cifar-10-batches-py/test_batch\")\nx_test = np.array(test[b'data'])\ny_test = np.array(test[b'labels'])\n\n# Load label names. For for convenience only.\nmeta = unpickle(\"/content/cifar-10-batches-py/batches.meta\",'utf-8')\nlabels= meta['label_names']\n\n", "_____no_output_____" ], [ "class NearestNeighbor:\n def __init__(self):\n pass\n\n def train(self,x,y):\n self.train_data = x\n self.train_labels = y\n \n def predict(self,x):\n # To avoid overflow data must be int, not a byte!\n distances = np.sum(np.abs(self.train_data - x),axis = 1) # Axis 0 it's a row num in image list \n return self.train_labels[np.argmin(distances)]\n", "_____no_output_____" ], [ "# Function to check model accuracy\ndef validate(model,x_test,y_test):\n correct = 0\n for i, sample in enumerate(x_test):\n index = model.predict(sample)\n correct += 1 if index == y_test[i] else 0\n if i > 0 and i % 100 == 0:\n print (\"Accuracy {:.3f}\".format(correct/i))\n \n return correct/len(x_test) ", "_____no_output_____" ], [ "# Now test accuracy and speed of model\nimport time\n\nnn = NearestNeighbor()\nnn.train(x_train,y_train)\n\nstart = time.perf_counter()\naccuracy = validate(nn,x_test[:100],y_test[:100]) \ntm = time.perf_counter() - start\ntotal = x_test.shape[0]\nprint(\"Accuracy {:.2f} Train {:d} /test {:d} in {:.1f} sec. speed {:.2f} samples per second.\".format(accuracy,len(x_train),total,tm,total/tm,) )", "Accuracy 0.34 Train 50000 /test 10000 in 46.4 sec. speed 215.56 samples per second.\n" ], [ "# KNN \n\nfrom collections import Counter\n\nclass KNearestNeighbor(NearestNeighbor):\n def __init__(self,k):\n self.k = k\n pass\n \n def predict(self,x):\n distances = np.sum(np.abs(self.train_data - x),axis = 1) # L1\n sorted_distance_indexes = np.argsort(distances)\n k_nearest_images = sorted_distance_indexes[:self.k]\n most_common = Counter(self.train_labels[k_nearest_images]).most_common()\n return most_common[0][0]\n\nknn = KNearestNeighbor(11)\nknn.train( x_train,y_train)\nvalidate(knn,x_test[:1000],y_test[:1000]) \n", "Accuracy 0.380\nAccuracy 0.410\nAccuracy 0.373\nAccuracy 0.375\nAccuracy 0.380\nAccuracy 0.383\n" ] ] ]

[ "markdown", "code" ]

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# **LetsGrowMore**\n\n---\n\n\n\n---\n# ***Data Science Internship***\n\n---\n\n\n\n---\n\n## `Author: UMER FAROOQ`\n## `Task Level: Beginner Level`\n## `Task Number: 1`\n## `Task Title: Iris Flower Classification`\n\n\n## `Language: Python`\n## `IDE: Google Colab`\n", "_____no_output_____" ], [ "# **Steps**:\n", "_____no_output_____" ], [ "# **Step:1**\n***Importing Libraries***", "_____no_output_____" ] ], [ [ "import numpy as np\nimport pandas as pd\nimport seaborn as sns\nsns.set_palette('husl')\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.model_selection import cross_val_score\nfrom sklearn.model_selection import StratifiedKFold\nfrom sklearn.metrics import classification_report\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.tree import DecisionTreeClassifier\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.svm import SVC", "_____no_output_____" ] ], [ [ "# **Step:2**\n***Loading the Dataset:*** I have pick the dataset from the following link. You can download the dataset as well as you can use by URL.", "_____no_output_____" ] ], [ [ "url = 'https://raw.githubusercontent.com/jbrownlee/Datasets/master/iris.csv'", "_____no_output_____" ], [ "# Creating the list of column name:\n\ncolumn_name = ['sepal-lenght','sepal-width','petal-lenght','petal-width','class']\n\n# Pandas read_csv() is used for reading the csv file:\n\ndataset = pd.read_csv(url, names = column_name)", "_____no_output_____" ] ], [ [ "# **Step:3**\n***Dataset Summarizing:*** Check the structure/shape of data on which we have to work on.", "_____no_output_____" ] ], [ [ "dataset.shape", "_____no_output_____" ] ], [ [ "This shows that we have: \n\n1. 150 rows,\n2. 5 columns.\n\nThats enough for our Beginner Project.\n*Displaying the First 5 records:*\n\n\n", "_____no_output_____" ] ], [ [ "dataset.head()", "_____no_output_____" ] ], [ [ "Pandas info() method prints information about a DataFrame such as datatypes, cols, NAN values and usage of memory:", "_____no_output_____" ] ], [ [ "dataset.info()", "<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 150 entries, 0 to 149\nData columns (total 5 columns):\n # Column Non-Null Count Dtype \n--- ------ -------------- ----- \n 0 sepal-lenght 150 non-null float64\n 1 sepal-width 150 non-null float64\n 2 petal-lenght 150 non-null float64\n 3 petal-width 150 non-null float64\n 4 class 150 non-null object \ndtypes: float64(4), object(1)\nmemory usage: 6.0+ KB\n" ], [ "dataset.isnull()", "_____no_output_____" ], [ "# Returns no. of missing records/values\ndataset.isnull().sum() ", "_____no_output_____" ], [ "\"\"\" Pandas describe() is used to view some basic statistical details like percentile, mean, std etc. of a data frame or a series of numeric values: \"\"\"\n\ndataset.describe()", "_____no_output_____" ] ], [ [ "**Now let’s check the number of rows that belongs to each class:**", "_____no_output_____" ] ], [ [ "dataset['class'].value_counts() # No of records/samples in each class", "_____no_output_____" ] ], [ [ "The above outputs shows that each class of flowers has 50 rows.", "_____no_output_____" ], [ "# **Step: 4 Data Visualization**\n\n---\n\n\n\n---\n\nData visualization is the process of translating large data sets and metrics into charts, graphs and other visuals.\n\n---\n\n\n\n---\n\n**Violin Plot:** Plotting the violin plot to check the comparison of a variable distribution:", "_____no_output_____" ] ], [ [ "sns.violinplot(y='class', x='sepal-lenght', data=dataset, inner='quartile')\nplt.show()\nprint('\\n')\n\nsns.violinplot(y='class', x='sepal-width', data=dataset, inner='quartile')\nplt.show()\nprint('\\n')\n\nsns.violinplot(y='class', x='petal-lenght', data=dataset, inner='quartile')\nplt.show()\nprint('\\n')\n\nsns.violinplot(y='class', x='petal-width', data=dataset, inner='quartile')\nplt.show()\nprint('\\n')", "_____no_output_____" ] ], [ [ "Above-plotted violin plot says that Iris-Setosa class is having a smaller petal length and petal width as compared to other class.", "_____no_output_____" ], [ "**Pair Plot:** Plotting multiple pairwise bivariate distributions in a dataset using pairplot:", "_____no_output_____" ] ], [ [ "sns.pairplot(dataset, hue='class', markers='+')\nplt.show()", "_____no_output_____" ] ], [ [ "From the above, we can see that Iris-Setosa is separated from both other species in all the features.", "_____no_output_____" ], [ "**Heatmap:** Plotting the heatmap to check the correlation.\n**dataset.corr()** is used to find the pairwise correlation of all columns in the dataframe.", "_____no_output_____" ] ], [ [ "plt.figure(figsize=(8,5))\nsns.heatmap(dataset.corr(), annot=True, cmap= 'PuOr')\nplt.show()", "_____no_output_____" ] ], [ [ "# **Step: 5 Model Construction (Splitting, Training and Model Creation)**\n\n---\n\n---\n\n\n**SPLITTING THE DATASET:**\nX have dependent variables.\nY have an independent variables.\n", "_____no_output_____" ] ], [ [ "x= dataset.drop(['class'], axis=1)\ny= dataset['class'] # Class is an independent variable\n\nprint('X shape: {}\\nY Shape: {}'.format(x.shape, y.shape))", "X shape: (150, 4)\nY Shape: (150,)\n" ] ], [ [ "The output shows that X has 150 records/rows and 4 cols, whereas, Y has 150 records and only 1 col.", "_____no_output_____" ], [ "**TRAINING THE TEST SPLIT:**\nSplitting our dataset into train and test using train_test_split(), what we are doing here is taking 80% of data to train our model, and 20% that we will hold back as a validation dataset:", "_____no_output_____" ] ], [ [ "x_train, x_test, y_train, y_test = train_test_split (x, y, test_size=0.20, random_state=1)", "_____no_output_____" ] ], [ [ "**MODEL CONSTRUCTION PART:1:**\nWe have no idea which algorithms might work best in this situation.\nLet's run each algorithm in a loop and print its accuracy so we can choose the best one. Following are the algorithms:\n\n1. Logistic Regression (LR)\n2. Linear Discriminant Analysis (LDA)\n\n1. K-Nearest Neighbors (KNN).\n2. Classification and Regression Trees (CART).\n\n1. Gaussian Naive Bayes (NB).\n2. Support Vector Machines (SVM).\n\n\n\n\n\n", "_____no_output_____" ] ], [ [ "models = []\nmodels.append(('LR', LogisticRegression()))\nmodels.append(('LDA', LinearDiscriminantAnalysis()))\nmodels.append(('KNN', KNeighborsClassifier()))\nmodels.append(('CART', DecisionTreeClassifier()))\nmodels.append(('NB', GaussianNB()))\nmodels.append(('SVC', SVC(gamma='auto')))\n# evaluate each model in turn\nresults = []\nmodel_names = []\nfor name, model in models:\n kfold = StratifiedKFold(n_splits=10, random_state=1, shuffle=True)\n cv_results = cross_val_score(model, x_train, y_train, cv=kfold, scoring='accuracy')\n results.append(cv_results)\n model_names.append(name)\n print('%s: %f (%f)' % (name, cv_results.mean(), cv_results.std()))", "/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\nSTOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n\nIncrease the number of iterations (max_iter) or scale the data as shown in:\n https://scikit-learn.org/stable/modules/preprocessing.html\nPlease also refer to the documentation for alternative solver options:\n https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\nSTOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n\nIncrease the number of iterations (max_iter) or scale the data as shown in:\n https://scikit-learn.org/stable/modules/preprocessing.html\nPlease also refer to the documentation for alternative solver options:\n https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\nSTOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n\nIncrease the number of iterations (max_iter) or scale the data as shown in:\n https://scikit-learn.org/stable/modules/preprocessing.html\nPlease also refer to the documentation for alternative solver options:\n https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\nSTOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n\nIncrease the number of iterations (max_iter) or scale the data as shown in:\n https://scikit-learn.org/stable/modules/preprocessing.html\nPlease also refer to the documentation for alternative solver options:\n https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n/usr/local/lib/python3.7/dist-packages/sklearn/linear_model/_logistic.py:940: ConvergenceWarning: lbfgs failed to converge (status=1):\nSTOP: TOTAL NO. of ITERATIONS REACHED LIMIT.\n\nIncrease the number of iterations (max_iter) or scale the data as shown in:\n https://scikit-learn.org/stable/modules/preprocessing.html\nPlease also refer to the documentation for alternative solver options:\n https://scikit-learn.org/stable/modules/linear_model.html#logistic-regression\n extra_warning_msg=_LOGISTIC_SOLVER_CONVERGENCE_MSG)\n" ] ], [ [ "***Support Vector Classifier (SVC) is performing better than other algorithms.\nLet’s train SVC model on our training set and predict on test set in the next step.***", "_____no_output_____" ], [ "**MODEL CONSTRUCTION PART:2**\n\nWe are defining our SVC model and passing gamma as auto.\n\nAfter that fitting/training the model on X_train and Y_train using .fit() method.\n\nThen we are predicting on X_test using .predict() method.", "_____no_output_____" ] ], [ [ "model = SVC(gamma='auto')\nmodel.fit(x_train, y_train)\nprediction = model.predict(x_test)", "_____no_output_____" ] ], [ [ "**Now checking the accuracy of the model using accuracy_score(y_test, prediction).**\n\ny_test is actually values of x_test\nprediction: it predicts values of x_test as mentioned earlier (*then we are predicting on X_test using .predict() method*).\n\n**Printing out the classfication report using:** classification_report(y_test, prediction)\n\n", "_____no_output_____" ] ], [ [ "print(f\"Test Accuracy: {accuracy_score(y_test, prediction)} \\n\")\nprint(f'Classification Report:\\n \\n {classification_report(y_test, prediction)}')", "Test Accuracy: 0.9666666666666667 \n\nClassification Report:\n \n precision recall f1-score support\n\n Iris-setosa 1.00 1.00 1.00 11\nIris-versicolor 1.00 0.92 0.96 13\n Iris-virginica 0.86 1.00 0.92 6\n\n accuracy 0.97 30\n macro avg 0.95 0.97 0.96 30\n weighted avg 0.97 0.97 0.97 30\n\n" ] ] ]

[ "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" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Estadística", "_____no_output_____" ], [ "Es la rama de las matemáticas que estudia la variabilidad, así como el proceso aleatorio que la genera siguiendo leyes de probabilidad.\n\nLa estadística es útil para una amplia variedad de ciencias empíricas (la que entiende los hechos creando representaciones de la realidad), desde la física hasta las ciencias sociales, desde las ciencias de la salud hasta el control de calidad. Además, se usa en áreas de negocios o instituciones gubernamentales con el objetivo de describir el conjunto de datos obtenidos para la toma de decisiones, o bien para realizar generalizaciones sobre las características observadas.", "_____no_output_____" ], [ "La estadística se divide en dos grandes áreas:\n\n- **Estadística descriptiva**: Se dedica a la descripción, visualización y resumen de datos originados a partir de los fenómenos de estudio. Los datos pueden ser resumidos numérica o gráficamente. Su objetivo es organizar y describir las características sobre un conjunto de datos con el propósito de facilitar su aplicación, generalmente con el apoyo de gráficas, tablas o medidas numéricas.\n\n - Ejemplos básicos de parámetros estadísticos son: la media y la desviación estándar.\n - Ejemplos gráficos son: histograma, pirámide poblacional, gráfico circular, entre otros.\n\n- **Estadística inferencial**: Se dedica a la generación de los modelos, inferencias y predicciones asociadas a los fenómenos en cuestión teniendo en cuenta la aleatoriedad de las observaciones. Se usa para modelar patrones en los datos y extraer inferencias acerca de la población bajo estudio. Estas inferencias pueden tomar la forma de respuestas a preguntas sí/no (prueba de hipótesis), estimaciones de unas características numéricas (estimación), pronósticos de futuras observaciones, descripciones de asociación (correlación) o modelamiento de relaciones entre variables (análisis de regresión). Otras técnicas de modelamiento incluyen análisis de varianza, series de tiempo y minería de datos. Su objetivo es obtener conclusiones útiles para lograr hacer deducciones acerca de la totalidad de todas las observaciones hechas, basándose en la información numérica.", "_____no_output_____" ], [ "# Sampling\n\n\n\nOne reason we need statistics is because we'd like to make statements about a general population based only on a subset - a *sample* - of the data. This can be for practical reasons, to reduce costs, or can be inherently necessary because of the nature of the problem. For example, it's not possible to collect data on \"everyone who ever had a headache\", so people wanting to study headaches will have to somehow get a group of people and try to generalize based on that.\n\nWhat's the right way to build that group? If a drug company decides to only ask its employees if their headache drug works, does that have any problems?\n\n*Yes* - let's discuss!", "_____no_output_____" ] ], [ [ "import random\npopulation = range(100)\nsample = random.sample(population, 10) #sample crea una muestra aleatorio dentro del rango\nprint(sample)", "[2, 78, 40, 59, 13, 31, 24, 43, 29, 68]\n" ] ], [ [ "--> Tarea Crear población a partir de lista de alturas de alumnos y con clases", "_____no_output_____" ], [ "## Conceptos básicos de la estadística descriptiva\n\nEn *[estadística descriptiva](https://es.wikipedia.org/wiki/Estad%C3%ADstica_descriptiva)* se utilizan distintas medidas para intentar describir las propiedades de nuestros datos, algunos de los conceptos básicos, son:\n\n* **Media aritmética**: La [media aritmética](https://es.wikipedia.org/wiki/Media_aritm%C3%A9tica) es el valor obtenido al sumar todos los *[datos](https://es.wikipedia.org/wiki/Dato)* y dividir el resultado entre el número total elementos. Se suele representar con la letra griega $\\mu$. Si tenemos una [muestra](https://es.wikipedia.org/wiki/Muestra_estad%C3%ADstica) de $n$ valores, $x_i$, la *media aritmética*, $\\mu$, es la suma de los valores divididos por el numero de elementos; en otras palabras:\n$$\\mu = \\frac{1}{n} \\sum_{i}x_i$$\n\n\n* **Desviación respecto a la media**: La desviación respecto a la media es la diferencia en valor absoluto entre cada valor de la variable estadística y la media aritmética.\n$$D_i = |x_i - \\mu|$$\n\n\n* **Varianza**: La [varianza](https://es.wikipedia.org/wiki/Varianza) es la media aritmética del cuadrado de las desviaciones respecto a la media de una distribución estadística. La varianza intenta describir la dispersión de los *[datos](https://es.wikipedia.org/wiki/Dato). Básicamente representa lo que varían los datos.* Se representa como $\\sigma^2$. \n$$\\sigma^2 = \\frac{\\sum\\limits_{i=1}^n(x_i - \\mu)^2}{n} $$\n\n\n* **Desviación típica**: La [desviación típica](https://es.wikipedia.org/wiki/Desviaci%C3%B3n_t%C3%ADpica) es la raíz cuadrada de la varianza. Se representa con la letra griega $\\sigma$.\n$$\\sigma = \\sqrt{\\frac{\\sum\\limits_{i=1}^n(x_i - \\mu)^2}{n}} $$\n\n\n* **Moda**: La <a href=\"https://es.wikipedia.org/wiki/Moda_(estad%C3%ADstica)\">moda</a> es el valor que tiene mayor frecuencia absoluta. Se representa con $M_0$\n\n\n* **Mediana**: La <a href=\"https://es.wikipedia.org/wiki/Mediana_(estad%C3%ADstica)\">mediana</a> es el valor que ocupa el lugar central de todos los datos cuando éstos están ordenados de menor a mayor. Se representa con $\\widetilde{x}$.\n\n\n* **Correlación**: La [correlación](https://es.wikipedia.org/wiki/Correlaci%C3%B3n) trata de establecer la relación o dependencia que existe entre las dos variables que intervienen en una distribución bidimensional. Es decir, determinar si los cambios en una de las variables influyen en los cambios de la otra. En caso de que suceda, diremos que las variables están correlacionadas o que hay correlación entre ellas. La correlación es positiva cuando los valores de las variables aumenta juntos; y es negativa cuando un valor de una variable se reduce cuando el valor de la otra variable aumenta.\n\n\n* **Covarianza**: La [covarianza](https://es.wikipedia.org/wiki/Covarianza) es el equivalente de la varianza aplicado a una variable bidimensional. Es la media aritmética de los productos de las desviaciones de cada una de las variables respecto a sus medias respectivas.La covarianza indica el sentido de la correlación entre las variables; Si $\\sigma_{xy} > 0$ la correlación es directa; Si $\\sigma_{xy} < 0$ la correlación es inversa.\n\n$$\\sigma_{xy} = \\frac{\\sum\\limits_{i=1}^n(x_i - \\mu_x)(y_i -\\mu_y)}{n}$$\n\n\n* **Valor atípico (Outlier)**: Un [valor atípico](https://es.wikipedia.org/wiki/Valor_at%C3%ADpico) es una observación que se aleja demasiado de la moda; esta muy lejos de la tendencia principal del resto de los *[datos](https://es.wikipedia.org/wiki/Dato)*. Pueden ser causados por errores en la recolección de *[datos](https://es.wikipedia.org/wiki/Dato)* o medidas inusuales. Generalmente se recomienda eliminarlos del [conjunto de datos](https://es.wikipedia.org/wiki/Conjunto_de_datos).\n", "_____no_output_____" ], [ "1. https://towardsdatascience.com/a-quick-guide-on-descriptive-statistics-using-pandas-and-seaborn-2aadc7395f32\n\n2. https://www.tutorialspoint.com/python_pandas/python_pandas_descriptive_statistics.htm", "_____no_output_____" ], [ "### Ejemplos en Python\n\nCalcular los principales indicadores de la *[estadística descriptiva](https://es.wikipedia.org/wiki/Estad%C3%ADstica_descriptiva)* con [Python](http://python.org/) es muy fácil!.", "_____no_output_____" ] ], [ [ "import numpy as np #np y pd es un alias. son librerias de estadistica y tratamientos de datos\nimport pandas as pd\nimport matplotlib.pyplot as pyplot\n#se instalan en terminal \n#pip3 install numpy", "_____no_output_____" ], [ "from numpy import *\n#importo las funciones de numpy a jupiter y se puede usar sin np.\n#no se recomienda", "_____no_output_____" ], [ "lista = [2, 4, 6, 8]\nprint(type(lista))\nlista_array = np.asarray(lista) #numpy trabaja con arrays. cambio de lista a array con asarray(lista) ARRAY tiene sus propios metodos incluidos en np\n#el equivalente a max(lista) q nos da el numero mas alto es lista_array.argmax()\n#list(lista_array) paso de array a lista\nprint(type(lista_array))", "<class 'list'>\n<class 'numpy.ndarray'>\n" ], [ "np.arange()", "_____no_output_____" ], [ "from scipy import unique, stats", "_____no_output_____" ], [ "# Ejemplos de estadistica descriptiva con python\n\nimport numpy as np # importando numpy\nfrom scipy import stats # importando scipy.stats\nimport pandas as pd # importando pandas\n\nnp.random.seed(4) # para poder replicar el random. fichero semilla seed", "_____no_output_____" ], [ "lista = [2., 1.76, 1.8, 1.6]\na = np.array(lista)\na", "_____no_output_____" ], [ "datos = np.random.randn(5, 4) # datos normalmente distribuidos. 5 filas y 4 columnas\ndatos #ya es un array de numpy", "_____no_output_____" ], [ "# media arítmetica\ndatos.mean() # Calcula la media aritmetica de los datos. no le alado np pq es un array q ya es de numpy", "_____no_output_____" ], [ "x = np.mean(datos) # Mismo resultado desde la funcion de numpy\nx", "_____no_output_____" ], [ "datos", "_____no_output_____" ], [ "datos.mean(axis=1) # media aritmetica de cada fila", "_____no_output_____" ], [ "datos.mean(axis=0) # media aritmetica de cada columna", "_____no_output_____" ], [ "# mediana\nnp.median(datos) ", "_____no_output_____" ], [ "np.median(datos, axis=0) # media aritmetica de cada columna", "_____no_output_____" ], [ "import numpy as np", "_____no_output_____" ], [ " # Desviación típica\nnp.std(datos)", "_____no_output_____" ], [ "type(datos)", "_____no_output_____" ], [ "datos.std()", "_____no_output_____" ], [ "np.std(datos, 0) # Desviación típica de cada columna", "_____no_output_____" ], [ "lista = [1, 3, 5, 7]\n\nnp.mean(a=lista)", "_____no_output_____" ], [ "x = np.array(lista)\nx", "_____no_output_____" ], [ "x.mean()", "_____no_output_____" ], [ "# varianza\nnp.var(datos) ", "_____no_output_____" ], [ "datos.var()", "_____no_output_____" ], [ "np.var(datos, 0) # varianza de cada columna", "_____no_output_____" ], [ "# moda\nstats.mode(datos) # Calcula la moda de cada columna\n# el 2do array devuelve la frecuencia.", "_____no_output_____" ], [ "datos2 = np.array([1, 2, 3, 6, 6, 1, 2, 4, 2, 2, 6, 6, 8, 10, 6])\nfrom scipy import stats # importando scipy.stats\n\nstats.mode(datos2) # aqui la moda es el 6 porque aparece 5 veces en el vector.", "_____no_output_____" ], [ "# correlacion\nnp.corrcoef(datos) # Crea matriz de correlación.", "_____no_output_____" ], [ "# calculando la correlación entre dos vectores.\nnp.corrcoef(datos[0], datos[1])", "_____no_output_____" ], [ "# covarianza\nnp.cov(datos) # calcula matriz de covarianza", "_____no_output_____" ], [ "# covarianza de dos vectores\nnp.cov(datos[0], datos[1])", "_____no_output_____" ], [ "datos", "_____no_output_____" ], [ "import pandas as pd\n# usando pandas\ndataframe = pd.DataFrame(datos, index=['a', 'b', 'c', 'd', 'e'], \n columns=['col1', 'col2', 'col3', 'col4'])\ndataframe", "_____no_output_____" ], [ "dataframe[\"col1\"].values", "_____no_output_____" ], [ "# resumen estadistadistico con pandas\ndataframe.describe()", "_____no_output_____" ], [ "lista = [2., 1.76, 1.8, 1.6]\nlista_array = np.array(lista)\nprint(lista_array)\ndataframe2 = pd.DataFrame(lista_array, index=['a', 'b', 'c', 'd'], \n columns=['col1'])\n\ndataframe2", "[2. 1.76 1.8 1.6 ]\n" ], [ "dataframe", "_____no_output_____" ], [ "# sumando las columnas\ndataframe.sum()", "_____no_output_____" ], [ "# sumando filas\ndataframe.sum(axis=1)", "_____no_output_____" ], [ "dataframe.cumsum() # acumulados\n\n", "_____no_output_____" ], [ "# media aritmética de cada columna con pandas\ndataframe.mean()", "_____no_output_____" ], [ "# media aritmética de cada fila con pandas\ndataframe.mean(axis=1)", "_____no_output_____" ], [ "altura1 = [1.78, 1.63, 1.75, 1.68]\naltura2 = [2.00, 1.82, 1.76, 1.66]\naltura3 = [1.65, 1.73, 1.75, 1.76]\naltura4 = [1.72, 1.71, 1.71, 1.62]\n\nlista_alturas = [altura1, altura2, altura3, altura4]\n\nclass Humano():\n def __init__(self, altura):\n self.altura = altura\n\n def crece(self):\n self.altura = self.altura + 2.0\n\nlista_humanos = []\n\nfor col_alt in lista_alturas:\n for alt in col_alt: \n humano = Humano(altura=alt)\n lista_humanos.append(humano)\n", "_____no_output_____" ], [ "lista_humanos", "_____no_output_____" ], [ "for humano in lista_humanos:\n print(humano.altura)\n humano.crece()\n print(humano.altura)\n print(\"----------\")", "1.78\n3.7800000000000002\n----------\n1.63\n3.63\n----------\n1.75\n3.75\n----------\n1.68\n3.6799999999999997\n----------\n2.0\n4.0\n----------\n1.82\n3.8200000000000003\n----------\n1.76\n3.76\n----------\n1.66\n3.66\n----------\n1.65\n3.65\n----------\n1.73\n3.73\n----------\n1.75\n3.75\n----------\n1.76\n3.76\n----------\n1.72\n3.7199999999999998\n----------\n1.71\n3.71\n----------\n1.71\n3.71\n----------\n1.62\n3.62\n----------\n" ], [ "lista_alturas", "_____no_output_____" ], [ "x = np.arange(0, 15)\nx", "_____no_output_____" ], [ "lista = [2, 5, 7]\nprint(sum(lista))", "14\n" ], [ "import numpy as np\ndef axis_x(limit):\n return np.arange(0, limit)\n\ntotal_elements_x = axis_x(limit=sum([len(x) for x in lista_alturas]))\ntotal_elements_x", "_____no_output_____" ], [ "lista_alturas_total = []\nfor humano in lista_humanos:\n lista_alturas_total.append(humano.altura)\narray_alturas_completo = np.array(lista_alturas_total).T\narray_alturas_completo\n", "_____no_output_____" ], [ "array_alturas_completo.shape", "_____no_output_____" ], [ "import pandas as pd", "_____no_output_____" ], [ "df = pd.DataFrame({'Alturas':array_alturas_completo})\ndf", "_____no_output_____" ], [ "import numpy as np\nimport pandas as pd \nimport matplotlib.pyplot as plt\n\nplt.plot(lista_alturas_alumnos, linewidth=2, marker='o', color=\"g\", linestyle='dashed', markersize=12)\nplt.ylabel(\"Alturas\")\nplt.show()", "_____no_output_____" ], [ "import mi_libreria as ml\n\nml.grafica_verde(lista=lista_alturas_alumnos, ylabel=\"Alturas 2\")", "_____no_output_____" ], [ "def create_array_with_same_value(value, limit):\n return np.full(limit, value)\n\na = create_array_with_same_value(2, 80)\na", "_____no_output_____" ], [ "a = np.arange(4)\na", "_____no_output_____" ], [ "media = np.mean(lista_alturas_alumnos)\nmedia_graph = create_array_with_same_value(value=media, limit=len(lista_alturas_alumnos))\nprint(lista_alturas_alumnos)\nmedia_graph", "[180, 180, 181, 173, 173, 175, 164, 189, 170, 167, 168, 160, 169, 176, 160, 175]\n" ], [ "print(len(lista_alturas_alumnos))\nprint(len(media_graph))", "16\n16\n" ], [ "# Añadimos la media a la gráfica\nplt.plot(lista_alturas_alumnos, \"ro\")\nmedia = np.mean(lista_alturas_alumnos)\nprint(\"Media:\", media)\nmedia_graph = create_array_with_same_value(value=media, limit=len(lista_alturas_alumnos))\n\nplt.ylabel(\"Alturas\")\nplt.plot(media_graph, \"b--\")\nplt.show()", "Media: 172.5\n" ], [ "lista_alturas_total = np.array(lista_alturas_total)\nstd = np.std(lista_alturas_total)\nstd", "_____no_output_____" ], [ "std_superior = media + std\nstd_inferior = media - std\n", "_____no_output_____" ], [ "plt.plot(lista_alturas_total, \"ro\")\nmedia = np.mean(lista_alturas_total)\nprint(\"Media:\", media)\nstd_superior_total = create_array_with_same_value(value=std_superior, limit=numero_de_alturas)\n\nstd_inferior_total = create_array_with_same_value(value=std_inferior, limit=numero_de_alturas)\n\nplt.ylabel(\"Alturas\")\nplt.plot(std_superior_total, \"b--\")\nplt.plot(std_inferior_total, \"g--\")\nplt.show()", "Media: 1.7331249999999998\n" ], [ "lista = [[[[2,4,6,8], [5,6,7,8]]]]\nlista_array = np.array(lista)\n\nlista_array", "_____no_output_____" ], [ "lista_array.shape", "_____no_output_____" ], [ "arrays_alturas = np.array([np.array(x) for x in lista_alturas])\narrays_alturas", "_____no_output_____" ], [ "np.mean(arrays_alturas)", "_____no_output_____" ], [ "np.mean(arrays_alturas, 1) # Fila", "_____no_output_____" ], [ "np.mean(arrays_alturas, 0) # Columna", "_____no_output_____" ], [ "lista = [2, 2, 2, 4, 6, 10, 10]\n\n2 --> 3\n4 --> 1\n6 --> 1\n10 -> 2\n\n", "_____no_output_____" ], [ "import pandas as pd\nimport numpy as np\n\ndf = pd.DataFrame({'Alturas':np.array(lista_alturas_alumnos)})\ndf\n\n", "_____no_output_____" ], [ "df.hist(bins=10)", "_____no_output_____" ] ], [ [ "## Histogramas y Distribuciones\n\nMuchas veces los indicadores de la *[estadística descriptiva](https://es.wikipedia.org/wiki/Estad%C3%ADstica_descriptiva)* no nos proporcionan una imagen clara de nuestros *[datos](https://es.wikipedia.org/wiki/Dato)*. Por esta razón, siempre es útil complementarlos con gráficos de las distribuciones de los *[datos](https://es.wikipedia.org/wiki/Dato)*, que describan con qué frecuencia aparece cada valor. La representación más común de una distribución es un [histograma](https://es.wikipedia.org/wiki/Histograma), que es un gráfico que muestra la frecuencia o probabilidad de cada valor. El [histograma](https://es.wikipedia.org/wiki/Histograma) muestra las frecuencias como un gráfico de barras que indica cuan frecuente un determinado valor ocurre en el [conjunto de datos](https://es.wikipedia.org/wiki/Conjunto_de_datos). El eje horizontal representa los valores del [conjunto de datos](https://es.wikipedia.org/wiki/Conjunto_de_datos) y el eje vertical representa la frecuencia con que esos valores ocurren.\n\nLas distribuciones se pueden clasificar en dos grandes grupos:\n\n1. Las **[distribuciones continuas](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_de_probabilidad_continua)**, que son aquellas que presentan un número infinito de posibles soluciones. Dentro de este grupo vamos a encontrar a las distribuciones: \n * [normal](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_normal),\n * [gamma](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_gamma),\n * [chi cuadrado](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_%CF%87%C2%B2), \n * [t de Student](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_t_de_Student), \n * [pareto](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_de_Pareto),\n * entre otras\n\n2. Las **distribuciones discretas**, que son aquellas en las que la variable puede pude tomar un número determinado de valores. Los principales exponenetes de este grupo son las distribuciones: \n * [poisson](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_de_Poisson),\n * [binomial](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_binomial),\n * [hipergeométrica](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_hipergeom%C3%A9trica),\n * [bernoulli](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_de_Bernoulli)\n * entre otras\n\nVeamos algunos ejemplos graficados con la ayuda de [Python](http://python.org/).", "_____no_output_____" ] ], [ [ "# Histogram\ndf.hist()", "_____no_output_____" ] ], [ [ "### Distribución normal\n\nLa [distribución normal](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_normal) es una de las principales distribuciones, ya que es la que con más frecuencia aparece aproximada en los fenómenos reales. Tiene una forma acampanada y es simétrica respecto de un determinado parámetro estadístico. Con la ayuda de [Python](http://python.org/) la podemos graficar de la siguiente manera:", "_____no_output_____" ] ], [ [ "# Graficos embebidos.\n%matplotlib inline ", "_____no_output_____" ], [ "import matplotlib.pyplot as plt # importando matplotlib\nimport seaborn as sns # importando seaborn\n\n# parametros esteticos de seaborn\nsns.set_palette(\"deep\", desat=.6)\nsns.set_context(rc={\"figure.figsize\": (8, 4)})", "_____no_output_____" ], [ "mu, sigma = 0, 0.1 # media y desvio estandar\ns = np.random.normal(mu, sigma, 1000) #creando muestra de datos", "_____no_output_____" ], [ "# histograma de distribución normal.\ncuenta, cajas, ignorar = plt.hist(s, 30, normed=True)\nnormal = plt.plot(cajas, 1/(sigma * np.sqrt(2 * np.pi)) *\n np.exp( - (cajas - mu)**2 / (2 * sigma**2) ),\n linewidth=2, color='r')", "_____no_output_____" ] ], [ [ "### Distribuciones simétricas y asimétricas\n\nUna distribución es simétrica cuando moda, mediana y media coinciden aproximadamente en sus valores. Si una distribución es simétrica, existe el mismo número de valores a la derecha que a la izquierda de la media, por tanto, el mismo número de desviaciones con signo positivo que con signo negativo.\n\nUna distribución tiene [asimetria](https://es.wikipedia.org/wiki/Asimetr%C3%ADa_estad%C3%ADstica) positiva (o a la derecha) si la \"cola\" a la derecha de la media es más larga que la de la izquierda, es decir, si hay valores más separados de la media a la derecha. De la misma forma una distribución tiene [asimetria](https://es.wikipedia.org/wiki/Asimetr%C3%ADa_estad%C3%ADstica) negativa (o a la izquierda) si la \"cola\" a la izquierda de la media es más larga que la de la derecha, es decir, si hay valores más separados de la media a la izquierda.\n\nLas distribuciones asimétricas suelen ser problemáticas, ya que la mayoría de los métodos estadísticos suelen estar desarrollados para distribuciones del tipo [normal](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_normal). Para salvar estos problemas se suelen realizar transformaciones a los datos para hacer a estas distribuciones más simétricas y acercarse a la [distribución normal](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_normal). ", "_____no_output_____" ] ], [ [ "# Dibujando la distribucion Gamma\nx = stats.gamma(3).rvs(5000)\ngamma = plt.hist(x, 70, histtype=\"stepfilled\", alpha=.7)", "_____no_output_____" ] ], [ [ "En este ejemplo podemos ver que la [distribución gamma](https://es.wikipedia.org/wiki/Distribuci%C3%B3n_gamma) que dibujamos tiene una [asimetria](https://es.wikipedia.org/wiki/Asimetr%C3%ADa_estad%C3%ADstica) positiva. ", "_____no_output_____" ] ], [ [ "# Calculando la simetria con scipy\nstats.skew(x)", "_____no_output_____" ] ], [ [ "## Cuartiles y diagramas de cajas\n\nLos **[cuartiles](https://es.wikipedia.org/wiki/Cuartil)** son los tres valores de la variable estadística que dividen a un [conjunto de datos](https://es.wikipedia.org/wiki/Conjunto_de_datos) ordenados en cuatro partes iguales. Q1, Q2 y Q3 determinan los valores correspondientes al 25%, al 50% y al 75% de los datos. Q2 coincide con la <a href=\"https://es.wikipedia.org/wiki/Mediana_(estad%C3%ADstica)\">mediana</a>.\n\nLos [diagramas de cajas](https://es.wikipedia.org/wiki/Diagrama_de_caja) son una presentación visual que describe varias características importantes al mismo tiempo, tales como la dispersión y simetría. Para su realización se representan los tres cuartiles y los valores mínimo y máximo de los datos, sobre un rectángulo, alineado horizontal o verticalmente. Estos gráficos nos proporcionan abundante información y son sumamente útiles para encontrar [valores atípicos](https://es.wikipedia.org/wiki/Valor_at%C3%ADpico) y comparar dos [conjunto de datos](https://es.wikipedia.org/wiki/Conjunto_de_datos). \n\n\n<img alt=\"diagrama de cajas\" title=\"Diagrama de cajas\" src=\"http://relopezbriega.github.io/images/diagCajas.png\" width=\"600\">", "_____no_output_____" ] ], [ [ "lista = [2, 3, 4, 5,6,7,9,10,11, 1000]", "_____no_output_____" ], [ "import matplotlib.pyplot as plt\n\n# Ejemplo de grafico de cajas en python\n\ndatos_1 = np.random.normal(100, 10, 200)\n#datos_2 = np.random.normal(80, 30, 200)\ndatos_3 = np.random.normal(90, 20, 200)\ndatos_4 = np.random.normal(70, 25, 200)\n\ndatos_graf = [datos_1, datos_2, datos_3, datos_4]\n\n# Creando el objeto figura\nfig = plt.figure(1, figsize=(9, 6))\n\n# Creando el subgrafico\nax = fig.add_subplot(111)\n\n# creando el grafico de cajas\nbp = ax.boxplot(datos_graf)\n\n# visualizar mas facile los atípicos\nfor flier in bp['fliers']:\n flier.set(marker='o', color='red', alpha=0.5)\n# los puntos aislados son valores atípicos", "_____no_output_____" ], [ "df = pd.DataFrame(datos_2)\ndf", "_____no_output_____" ], [ "es_menor_a_80 = 0\nfor value in datos_2:\n if value <= 80:\n es_menor_a_80 += 1\n\nprint(es_menor_a_80)", "103\n" ], [ "df.hist(bins=2)", "_____no_output_____" ], [ "x = list(datos_2)\nx.append(500)\ndatos_2 = np.array(x)\ndf = pd.DataFrame(datos_2)\ndf.hist()", "_____no_output_____" ], [ "# usando seaborn\nsns.boxplot(datos_graf, names=[\"grupo1\", \"grupo2\", \"grupo3\", \"grupo 4\"],\n color=\"PaleGreen\");", "_____no_output_____" ] ] ]

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

[ [ "markdown", "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown", "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", "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" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "list=[1,2,3,4,5]\nlist[::-1]", "_____no_output_____" ], [ "array=[1,2,3,4,5]\ndef revlist(A,start,end):\n while start<end:\n A[start],A[end]=A[end],A[start]\n start += 1\n end -= 1\n return A\nrevlist(array,0,len(array)-1)", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Data Aggregation and Group Operations", "_____no_output_____" ] ], [ [ "import numpy as np\r\nimport pandas as pd\r\nPREVIOUS_MAX_ROWS = pd.options.display.max_rows\r\npd.options.display.max_rows = 20\r\nnp.random.seed(12345)\r\nimport matplotlib.pyplot as plt\r\nplt.rc('figure', figsize=(10, 6))\r\nnp.set_printoptions(precision=4, suppress=True)", "_____no_output_____" ] ], [ [ "## 10.1. GroupBy Mechanics", "_____no_output_____" ], [ "### 10.1.0", "_____no_output_____" ], [ "To get started, here is a small tabular dataset as a DataFrame:", "_____no_output_____" ] ], [ [ "df = pd.DataFrame({'key1' : ['a', 'a', 'b', 'b', 'a'],\r\n 'key2' : ['one', 'two', 'one', 'two', 'one'],\r\n 'data1' : np.random.randn(5),\r\n 'data2' : np.random.randn(5)})\r\ndf", "_____no_output_____" ] ], [ [ "Suppose you wanted to *compute the mean of the data1 column* using the *labels from key1*.<br>\r\nThere are a number of ways to do this.<br>\r\n* One is to access data1 and call groupby with the column (a Series) at key1:", "_____no_output_____" ] ], [ [ "grouped = df['data1'].groupby(df['key1'])\r\ngrouped", "_____no_output_____" ] ], [ [ "This grouped variable is now a GroupBy object. It has not actually computed anything yet except for some intermediate data about the group key df['key1']. The idea is that this object has all of the information needed to then apply some operation to each of the groups.<br>\r\n\r\nFor example, to compute group means we can call the GroupBy’s mean method:", "_____no_output_____" ] ], [ [ "grouped.mean()", "_____no_output_____" ] ], [ [ "Later, I’ll explain more about what happens when you call .mean(). The important thing here is that `the data (a Series) has been aggregated according to the group key`, producing a new Series that is now indexed by the unique values in the key1 column. The result index has the name 'key1' because the DataFrame column df['key1'] did.<br>\r\n\r\nIf instead we had passed multiple arrays as a list, we’d get something different:", "_____no_output_____" ] ], [ [ "means = df['data1'].groupby([df['key1'], df['key2']]).mean()\r\nmeans", "_____no_output_____" ] ], [ [ "Here we grouped the data using two keys (@P:key 1 + key 2 above), and the resulting Series now has a hierarchical index consisting of the unique pairs of keys observed:", "_____no_output_____" ] ], [ [ "means.unstack()", "_____no_output_____" ] ], [ [ "In this example, the group keys are all Series, though they could be any arrays of the right length:", "_____no_output_____" ] ], [ [ "states = np.array(['Ohio', 'California', 'California', 'Ohio', 'Ohio'])\r\nyears = np.array([2005, 2005, 2006, 2005, 2006])\r\ndf['data1'].groupby([states, years]).mean()", "_____no_output_____" ] ], [ [ "Frequently the grouping information is found in the same DataFrame as the data you want to work on. In that case, you can pass column names (whether those are strings, numbers, or other Python objects) as the group keys:", "_____no_output_____" ] ], [ [ "df.groupby('key1').mean()", "_____no_output_____" ], [ "df.groupby(['key1', 'key2']).mean()", "_____no_output_____" ] ], [ [ "You may have noticed in the first case df.groupby('key1').mean() that there is no key2 column in the result. *Because df['key2'] is not numeric data*, it is said to be a `nuisance column`, which is therefore excluded from the result. `By default, all of the numeric columns are aggregated`, though it is possible to filter down to a subset, as you’ll see soon.<br>\r\nRegardless of the objective in using groupby, a generally useful GroupBy method is size, which returns a Series containing group sizes:", "_____no_output_____" ] ], [ [ "df.groupby(['key1', 'key2']).size()", "_____no_output_____" ] ], [ [ "Take note that any missing values in a group key will be excluded from the result.", "_____no_output_____" ], [ "### 10.1.1. Iterating Over Groups", "_____no_output_____" ], [ "The `GroupBy object supports iteration`, generating a sequence of 2-tuples containing the group name along with the chunk of data. Consider the following:", "_____no_output_____" ] ], [ [ "for name, group in df.groupby('key1'):\r\n print(name)\r\n print(group)", "a\n key1 key2 data1 data2\n0 a one -0.204708 1.393406\n1 a two 0.478943 0.092908\n4 a one 1.965781 1.246435\nb\n key1 key2 data1 data2\n2 b one -0.519439 0.281746\n3 b two -0.555730 0.769023\n" ] ], [ [ "In the case of multiple keys, the first element in the tuple will be a tuple of key values:", "_____no_output_____" ] ], [ [ "for (k1, k2), group in df.groupby(['key1', 'key2']):\r\n print((k1, k2))\r\n print(group)", "('a', 'one')\n key1 key2 data1 data2\n0 a one -0.204708 1.393406\n4 a one 1.965781 1.246435\n('a', 'two')\n key1 key2 data1 data2\n1 a two 0.478943 0.092908\n('b', 'one')\n key1 key2 data1 data2\n2 b one -0.519439 0.281746\n('b', 'two')\n key1 key2 data1 data2\n3 b two -0.55573 0.769023\n" ] ], [ [ "Of course, you can choose to do whatever you want with the pieces of data. *A recipe you may find useful* is `computing a dict of the data pieces as a one-liner`:", "_____no_output_____" ] ], [ [ "pieces = dict(list(df.groupby('key1')))\r\npieces\r\n# pieces['b']", "_____no_output_____" ] ], [ [ "By default groupby groups on `axis=0`, but you `can group on any of the other axes`. For example, we could group the columns of our example df here by dtype like so:", "_____no_output_____" ] ], [ [ "df.dtypes", "_____no_output_____" ], [ "grouped = df.groupby(df.dtypes, axis=1)\r\ngrouped", "_____no_output_____" ], [ "#We can print out the groups like so:\r\nfor dtype, group in grouped:\r\n print(dtype)\r\n print(group)", "float64\n data1 data2\n0 -0.204708 1.393406\n1 0.478943 0.092908\n2 -0.519439 0.281746\n3 -0.555730 0.769023\n4 1.965781 1.246435\nobject\n key1 key2\n0 a one\n1 a two\n2 b one\n3 b two\n4 a one\n" ] ], [ [ "### 10.1.2. Selecting a Column or Subset of Columns", "_____no_output_____" ], [ "Indexing a GroupBy object created from a DataFrame with a column name or array of column names has the effect of column subsetting for aggregation. This means that:", "_____no_output_____" ] ], [ [ "df.groupby('key1')['data1']\r\ndf.groupby('key1')[['data2']]", "_____no_output_____" ] ], [ [ "are `syntactic sugar` for:", "_____no_output_____" ] ], [ [ "df['data1'].groupby(df['key1'])\r\ndf[['data2']].groupby(df['key1'])", "_____no_output_____" ] ], [ [ "Especially for large datasets, it may be desirable to aggregate only a few columns.<br>\r\nFor example, in the preceding dataset, to *compute means for just the data2 column* and get the result as a DataFrame, we could write:", "_____no_output_____" ] ], [ [ "df.groupby(['key1', 'key2'])[['data2']].mean()", "_____no_output_____" ] ], [ [ "`The object returned by this indexing operation is a grouped DataFrame` if a *list or array* is passed or` a grouped Series` if only a *single column name is passed* as a scalar:", "_____no_output_____" ] ], [ [ "s_grouped = df.groupby(['key1', 'key2'])['data2']\r\ns_grouped", "_____no_output_____" ], [ "s_grouped.mean()", "_____no_output_____" ] ], [ [ "### 10.1.3. Grouping with Dicts and Series", "_____no_output_____" ], [ "Grouping information may exist in a form other than an array. Let’s consider another example DataFrame:", "_____no_output_____" ] ], [ [ "people = pd.DataFrame(np.random.randn(5, 5),\r\n columns=['a', 'b', 'c', 'd', 'e'],\r\n index=['Joe', 'Steve', 'Wes', 'Jim', 'Travis'])\r\npeople.iloc[2:3, [1, 2]] = np.nan # Add a few NA values\r\npeople", "_____no_output_____" ] ], [ [ "Now, suppose I have a group correspondence for the columns and want to sum together the columns by group:", "_____no_output_____" ] ], [ [ "mapping = {'a': 'red', 'b': 'red', 'c': 'blue',\r\n 'd': 'blue', 'e': 'red', 'f' : 'orange'}\r\nmapping", "_____no_output_____" ] ], [ [ "Now, you could construct an array from this dict to pass to groupby, but instead we can just pass the dict (I included the key 'f' to highlight that unused grouping keys are OK):", "_____no_output_____" ] ], [ [ "by_column = people.groupby(mapping, axis=1)\r\nby_column.sum()", "_____no_output_____" ] ], [ [ "`The same functionality holds for Series`, which can be viewed as a *fixedsize mapping*:", "_____no_output_____" ] ], [ [ "map_series = pd.Series(mapping)\r\nmap_series", "_____no_output_____" ], [ "people.groupby(map_series, axis=1).count()", "_____no_output_____" ] ], [ [ "### 10.1.4. Grouping with Functions", "_____no_output_____" ], [ "Using Python functions is a more generic way of defining a group mapping compared with a dict or Series. `Any function passed as a group key will be called once per index value, with the return values being used as the group names`.<br>\r\nMore concretely, consider the example DataFrame from the previous section, which has people’s first names as index values. Suppose you wanted to group by the length of the names; while you could compute an array of string lengths, it’s simpler to just pass the len function:", "_____no_output_____" ] ], [ [ "people.groupby(len).sum()", "_____no_output_____" ] ], [ [ "Mixing functions with arrays, dicts, or Series is not a problem as everything gets converted to arrays internally:", "_____no_output_____" ] ], [ [ "key_list = ['one', 'one', 'one', 'two', 'two']\r\npeople.groupby([len, key_list]).min()\r\n#@P 20210901: not understand how key_list function in this syntax", "_____no_output_____" ] ], [ [ "### 10.1.5. Grouping by Index Levels", "_____no_output_____" ], [ "A final convenience for hierarchically indexed datasets is the ability to aggregate using one of the levels of an axis index.<br>\r\nLet’s look at an example:", "_____no_output_____" ] ], [ [ "columns = pd.MultiIndex.from_arrays([['US', 'US', 'US', 'JP', 'JP'],\r\n [1, 3, 5, 1, 3]],\r\n names=['cty', 'tenor'])\r\nhier_df = pd.DataFrame(np.random.randn(4, 5), columns=columns)\r\nhier_df", "_____no_output_____" ] ], [ [ "* *To group by level*, pass the level number or name using the level keyword:", "_____no_output_____" ] ], [ [ "hier_df.groupby(level='cty', axis=1).count()", "_____no_output_____" ] ], [ [ "## 10.2. Data Aggregation", "_____no_output_____" ], [ "`Aggregations` refer to *any data transformation that produces scalar values from arrays*. The preceding examples have used several of them, including *mean, count, min, and sum*.", "_____no_output_____" ], [ "While `quantile` is not explicitly implemented for GroupBy, it is a Series method and thus available for use. Internally, *GroupBy efficiently slices up the Series*, *calls piece.quantile(0.9) for each piece*, and then *assembles those results together into the result object*:", "_____no_output_____" ] ], [ [ "df", "_____no_output_____" ], [ "grouped = df.groupby('key1')\r\ngrouped['data1'].quantile(0.9)", "_____no_output_____" ] ], [ [ "To use your own aggregation functions, pass any function that aggregates an array to the `aggregate` or `agg method`:", "_____no_output_____" ] ], [ [ "def peak_to_peak(arr):\r\n return arr.max() - arr.min()\r\ngrouped.agg(peak_to_peak)", "D:\\Users\\phu.le2\\Anaconda3\\lib\\site-packages\\pandas\\core\\groupby\\generic.py:303: FutureWarning: Dropping invalid columns in SeriesGroupBy.agg is deprecated. In a future version, a TypeError will be raised. Before calling .agg, select only columns which should be valid for the aggregating function.\n results[key] = self.aggregate(func)\n" ], [ "def peak_to_peak(arr):\r\n return arr.max() - arr.min()\r\ngrouped.aggregate(peak_to_peak)\r\n#@P 20210902: due to the warning that SeriesGroupBy.agg is deprecated -> change to this method but it seems to me that the results are not the same", "D:\\Users\\phu.le2\\Anaconda3\\lib\\site-packages\\pandas\\core\\groupby\\generic.py:303: FutureWarning: Dropping invalid columns in SeriesGroupBy.agg is deprecated. In a future version, a TypeError will be raised. Before calling .agg, select only columns which should be valid for the aggregating function.\n results[key] = self.aggregate(func)\n" ] ], [ [ "You may notice that some methods like `describe` also work, even though they are not aggregations, strictly speaking:", "_____no_output_____" ] ], [ [ "grouped.describe()", "_____no_output_____" ] ], [ [ "**NOTE**\r\n*Custom aggregation functions are generally much slower than the optimized functions found in Table 10-1* *(count, sum, mean, meadiam, std, var, min, max, prod, first, last)*. This is because there is some extra overhead (function calls, data rearrangement) in constructing the intermediate group data chunks.", "_____no_output_____" ], [ "### 10.2.1. Column-Wise and Multiple Function Application", "_____no_output_____" ], [ "Let’s return to the tipping dataset from earlier examples. After loading it with read_csv, we add a tipping percentage column tip_pct:", "_____no_output_____" ] ], [ [ "tips = pd.read_csv('examples/tips.csv')\r\ntips.head()", "_____no_output_____" ], [ "# Add tip percentage of total bill\r\ntips['tip_pct'] = tips['tip'] / tips['total_bill']\r\ntips[:6]", "_____no_output_____" ] ], [ [ "As you’ve already seen, aggregating a Series or all of the columns of a DataFrame is a matter of using `aggregate` with the desired function or calling a method like mean or std. However, you may want to aggregate using a different function depending on the column, or multiple functions at once. Fortunately, this is possible to do, which I’ll illustrate through a number of examples.<br>\r\nFirst, I’ll group the tips by day and smoker:", "_____no_output_____" ] ], [ [ "rouped = tips.groupby(['day', 'smoker'])\r\ngrouped", "_____no_output_____" ] ], [ [ "Note that for descriptive statistics like those in Table 10-1, you can pass the name of the function as a string:", "_____no_output_____" ] ], [ [ "grouped_pct = grouped['tip_pct']\r\ngrouped_pct", "_____no_output_____" ], [ "grouped_pct.agg('mean')", "_____no_output_____" ] ], [ [ "If you p*ass a list of functions or function names* instead, you get back a DataFrame with column names taken from the functions:", "_____no_output_____" ] ], [ [ "grouped_pct.agg(['mean', 'std', peak_to_peak])", "_____no_output_____" ] ], [ [ "Here we passed a list of aggregation functions to `agg` to evaluate indepedently on the data groups.", "_____no_output_____" ], [ "`You don’t need to accept the names that GroupBy gives to the columns`; notably, lambda functions have the name '<lambda>', which makes them hard to identify (you can see for yourself by looking at a function’s __name__ attribute). Thus, *if you pass a list of (name, function) tuples,* `the first element of each tuple will be used as the DataFrame column names` (you can think of a list of 2-tuples as an ordered mapping):", "_____no_output_____" ] ], [ [ "grouped_pct.agg([('foo', 'mean'), ('bar', np.std)])\r\n#@P: mean and std but are named as foo and bar", "_____no_output_____" ] ], [ [ "With a DataFrame you have more options, as you can specify a list of functions to apply to all of the columns or different functions per column.", "_____no_output_____" ], [ "To start, suppose we wanted to compute the same three statistics for the *tip_pct* and *total_bill* columns:", "_____no_output_____" ] ], [ [ "functions = ['count', 'mean', 'max']\r\nresult = grouped['tip_pct', 'total_bill'].agg(functions)\r\nresult", "<ipython-input-274-f8119a6d3215>:2: FutureWarning: Indexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.\n result = grouped['tip_pct', 'total_bill'].agg(functions)\n" ], [ "grouped", "_____no_output_____" ], [ "#to deal with FutureWarning: Indexing with multiple keys (implicitly converted to a tuple of keys) will be deprecated, use a list instead.\r\n#https://stackoverflow.com/questions/61634759/python-futurewarning-indexing-with-multiple-keys-implicitly-converted-to-a-tup -> extra bracket to solve it\r\nfunctions = ['count', 'mean', 'max']\r\nresult = grouped[['tip_pct', 'total_bill']].agg(functions)\r\nresult", "_____no_output_____" ] ], [ [ "As you can see, the resulting DataFrame has hierarchical columns, the same as you would get aggregating each column separately and using `concat` to glue the results together using the column names as the keys argument:", "_____no_output_____" ] ], [ [ "result['tip_pct']", "_____no_output_____" ] ], [ [ "As before, a list of tuples with custom names can be passed:", "_____no_output_____" ] ], [ [ "ftuples = [('Durchschnitt', 'mean'), ('Abweichung', np.var)] #@P: mean and var is named with different name as Durchschnitt and Abweichung)\r\ngrouped[['tip_pct', 'total_bill']].agg(ftuples)", "_____no_output_____" ] ], [ [ "Now, suppose you wanted to *apply potentially different functions* to one or more of the columns. To do this, `pass a dict to agg that contains a mapping of column names` to any of the function specifications listed so far:", "_____no_output_____" ] ], [ [ "grouped.agg({'tip' : np.max, 'size' : 'sum'})", "_____no_output_____" ], [ "grouped.agg({'tip_pct' : ['min', 'max', 'mean', 'std'],\r\n 'size' : 'sum'})", "_____no_output_____" ] ], [ [ "### 10.2.2. Returning Aggregated Data Without Row Indexes", "_____no_output_____" ], [ "In all of the examples up until now, `the aggregated data comes back with an index, potentially hierarchical, composed from the unique group key combinations`. Since this isn’t always desirable, *you can disable this behavior in most cases by passing* `as_index=False` to groupby:", "_____no_output_____" ] ], [ [ "tips.groupby(['day', 'smoker'], as_index=False).mean()", "_____no_output_____" ] ], [ [ "## 10.3. Apply: General split-apply-combine", "_____no_output_____" ], [ "#### 10.3.0", "_____no_output_____" ], [ "Returning to the tipping dataset from before, *suppose you wanted to select the top five tip_pct values by group*. \r\n* First, write a function that selects the rows with the largest values in a particular column:", "_____no_output_____" ] ], [ [ "def top(df, n=5, column='tip_pct'):\r\n return df.sort_values(by=column)[-n:]\r\ntop(tips, n=6)", "_____no_output_____" ] ], [ [ "Now, if we group by smoker, say, and call apply with this function, we get the following:", "_____no_output_____" ] ], [ [ "tips.groupby('smoker').apply(top)", "_____no_output_____" ] ], [ [ "What has happened here?<br>\r\n* The top function is called on each row group from the DataFrame, and then the results are glued together using `pandas.concat`, labeling the pieces with the group names.<br>\r\nThe result therefore has *a hierarchical index* whose inner level contains index values from the original DataFrame.", "_____no_output_____" ], [ "If you pass a function to `apply` that takes other arguments or keywords, you can pass these after the function:", "_____no_output_____" ] ], [ [ "tips.groupby(['smoker', 'day']).apply(top, n=1, column='total_bill')\r\n#@P: additional config to the function: n= 1 and apply the function on column total_bill, not the default n =5 and column='tip_pct'", "_____no_output_____" ] ], [ [ "**NOTE**<br>\r\nBeyond these basic usage mechanics, getting the most out of apply may require some creativity. What occurs inside the function passed is up to you; `it only needs to return a pandas object or a scalar value`. The rest of this chapter will mainly consist of examples showing you how to solve various problems using groupby.", "_____no_output_____" ], [ "You may recall that I earlier called `describe` on a GroupBy object:", "_____no_output_____" ] ], [ [ "result = tips.groupby('smoker')['tip_pct'].describe()\r\nresult", "_____no_output_____" ], [ "result.unstack('smoker')", "_____no_output_____" ] ], [ [ "Inside GroupBy, when you invoke a method like `describe`, *it is actually just a shortcut for*:", "_____no_output_____" ] ], [ [ "f = lambda x: x.describe()\r\ngrouped.apply(f)", "_____no_output_____" ] ], [ [ "### 10.3.1. Suppressing the Group Keys", "_____no_output_____" ], [ "In the preceding examples, you see that the *resulting object has a hierarchical index* formed from the group keys along with the indexes of each piece of the original object. You can *disable this by passing* `group_keys=False`to *groupby*:", "_____no_output_____" ] ], [ [ "tips.groupby('smoker', group_keys=False).apply(top)", "_____no_output_____" ] ], [ [ "### 10.3.2. Quantile and Bucket Analysis", "_____no_output_____" ], [ "As you may `recall from Chapter 8`, pandas has some tools, in particular `cut and qcut`, *for slicing data up into buckets with bins of your choosing or by sample quantiles*. `Combining these functions with groupby makes it convenient to perform bucket or quantile analysis on a dataset`.<br>\r\nConsider a simple random dataset and an equal-length bucket categorization using cut:", "_____no_output_____" ] ], [ [ "#@P checking syntax docstring\r\nnp.random.randn??", "\u001b[1;31mDocstring:\u001b[0m\nrandn(d0, d1, ..., dn)\n\nReturn a sample (or samples) from the \"standard normal\" distribution.\n\n.. note::\n This is a convenience function for users porting code from Matlab,\n and wraps `standard_normal`. That function takes a\n tuple to specify the size of the output, which is consistent with\n other NumPy functions like `numpy.zeros` and `numpy.ones`.\n\n.. note::\n New code should use the ``standard_normal`` method of a ``default_rng()``\n instance instead; please see the :ref:`random-quick-start`.\n\nIf positive int_like arguments are provided, `randn` generates an array\nof shape ``(d0, d1, ..., dn)``, filled\nwith random floats sampled from a univariate \"normal\" (Gaussian)\ndistribution of mean 0 and variance 1. A single float randomly sampled\nfrom the distribution is returned if no argument is provided.\n\nParameters\n----------\nd0, d1, ..., dn : int, optional\n The dimensions of the returned array, must be non-negative.\n If no argument is given a single Python float is returned.\n\nReturns\n-------\nZ : ndarray or float\n A ``(d0, d1, ..., dn)``-shaped array of floating-point samples from\n the standard normal distribution, or a single such float if\n no parameters were supplied.\n\nSee Also\n--------\nstandard_normal : Similar, but takes a tuple as its argument.\nnormal : Also accepts mu and sigma arguments.\nGenerator.standard_normal: which should be used for new code.\n\nNotes\n-----\nFor random samples from :math:`N(\\mu, \\sigma^2)`, use:\n\n``sigma * np.random.randn(...) + mu``\n\nExamples\n--------\n>>> np.random.randn()\n2.1923875335537315 # random\n\nTwo-by-four array of samples from N(3, 6.25):\n\n>>> 3 + 2.5 * np.random.randn(2, 4)\narray([[-4.49401501, 4.00950034, -1.81814867, 7.29718677], # random\n [ 0.39924804, 4.68456316, 4.99394529, 4.84057254]]) # random\n\u001b[1;31mType:\u001b[0m builtin_function_or_method\n" ], [ "#@P checking syntax docstring\r\npd.cut?", "\u001b[1;31mSignature:\u001b[0m\n\u001b[0mpd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mcut\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mbins\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mright\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mretbins\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mprecision\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mint\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0minclude_lowest\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mduplicates\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'raise'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mordered\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;31mDocstring:\u001b[0m\nBin values into discrete intervals.\n\nUse `cut` when you need to segment and sort data values into bins. This\nfunction is also useful for going from a continuous variable to a\ncategorical variable. For example, `cut` could convert ages to groups of\nage ranges. Supports binning into an equal number of bins, or a\npre-specified array of bins.\n\nParameters\n----------\nx : array-like\n The input array to be binned. Must be 1-dimensional.\nbins : int, sequence of scalars, or IntervalIndex\n The criteria to bin by.\n\n * int : Defines the number of equal-width bins in the range of `x`. The\n range of `x` is extended by .1% on each side to include the minimum\n and maximum values of `x`.\n * sequence of scalars : Defines the bin edges allowing for non-uniform\n width. No extension of the range of `x` is done.\n * IntervalIndex : Defines the exact bins to be used. Note that\n IntervalIndex for `bins` must be non-overlapping.\n\nright : bool, default True\n Indicates whether `bins` includes the rightmost edge or not. If\n ``right == True`` (the default), then the `bins` ``[1, 2, 3, 4]``\n indicate (1,2], (2,3], (3,4]. This argument is ignored when\n `bins` is an IntervalIndex.\nlabels : array or False, default None\n Specifies the labels for the returned bins. Must be the same length as\n the resulting bins. If False, returns only integer indicators of the\n bins. This affects the type of the output container (see below).\n This argument is ignored when `bins` is an IntervalIndex. If True,\n raises an error. When `ordered=False`, labels must be provided.\nretbins : bool, default False\n Whether to return the bins or not. Useful when bins is provided\n as a scalar.\nprecision : int, default 3\n The precision at which to store and display the bins labels.\ninclude_lowest : bool, default False\n Whether the first interval should be left-inclusive or not.\nduplicates : {default 'raise', 'drop'}, optional\n If bin edges are not unique, raise ValueError or drop non-uniques.\nordered : bool, default True\n Whether the labels are ordered or not. Applies to returned types\n Categorical and Series (with Categorical dtype). If True,\n the resulting categorical will be ordered. If False, the resulting\n categorical will be unordered (labels must be provided).\n\n .. versionadded:: 1.1.0\n\nReturns\n-------\nout : Categorical, Series, or ndarray\n An array-like object representing the respective bin for each value\n of `x`. The type depends on the value of `labels`.\n\n * True (default) : returns a Series for Series `x` or a\n Categorical for all other inputs. The values stored within\n are Interval dtype.\n\n * sequence of scalars : returns a Series for Series `x` or a\n Categorical for all other inputs. The values stored within\n are whatever the type in the sequence is.\n\n * False : returns an ndarray of integers.\n\nbins : numpy.ndarray or IntervalIndex.\n The computed or specified bins. Only returned when `retbins=True`.\n For scalar or sequence `bins`, this is an ndarray with the computed\n bins. If set `duplicates=drop`, `bins` will drop non-unique bin. For\n an IntervalIndex `bins`, this is equal to `bins`.\n\nSee Also\n--------\nqcut : Discretize variable into equal-sized buckets based on rank\n or based on sample quantiles.\nCategorical : Array type for storing data that come from a\n fixed set of values.\nSeries : One-dimensional array with axis labels (including time series).\nIntervalIndex : Immutable Index implementing an ordered, sliceable set.\n\nNotes\n-----\nAny NA values will be NA in the result. Out of bounds values will be NA in\nthe resulting Series or Categorical object.\n\nExamples\n--------\nDiscretize into three equal-sized bins.\n\n>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3)\n... # doctest: +ELLIPSIS\n[(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...\nCategories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...\n\n>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3, retbins=True)\n... # doctest: +ELLIPSIS\n([(0.994, 3.0], (5.0, 7.0], (3.0, 5.0], (3.0, 5.0], (5.0, 7.0], ...\nCategories (3, interval[float64, right]): [(0.994, 3.0] < (3.0, 5.0] ...\narray([0.994, 3. , 5. , 7. ]))\n\nDiscovers the same bins, but assign them specific labels. Notice that\nthe returned Categorical's categories are `labels` and is ordered.\n\n>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]),\n... 3, labels=[\"bad\", \"medium\", \"good\"])\n['bad', 'good', 'medium', 'medium', 'good', 'bad']\nCategories (3, object): ['bad' < 'medium' < 'good']\n\n``ordered=False`` will result in unordered categories when labels are passed.\nThis parameter can be used to allow non-unique labels:\n\n>>> pd.cut(np.array([1, 7, 5, 4, 6, 3]), 3,\n... labels=[\"B\", \"A\", \"B\"], ordered=False)\n['B', 'B', 'A', 'A', 'B', 'B']\nCategories (2, object): ['A', 'B']\n\n``labels=False`` implies you just want the bins back.\n\n>>> pd.cut([0, 1, 1, 2], bins=4, labels=False)\narray([0, 1, 1, 3])\n\nPassing a Series as an input returns a Series with categorical dtype:\n\n>>> s = pd.Series(np.array([2, 4, 6, 8, 10]),\n... index=['a', 'b', 'c', 'd', 'e'])\n>>> pd.cut(s, 3)\n... # doctest: +ELLIPSIS\na (1.992, 4.667]\nb (1.992, 4.667]\nc (4.667, 7.333]\nd (7.333, 10.0]\ne (7.333, 10.0]\ndtype: category\nCategories (3, interval[float64, right]): [(1.992, 4.667] < (4.667, ...\n\nPassing a Series as an input returns a Series with mapping value.\nIt is used to map numerically to intervals based on bins.\n\n>>> s = pd.Series(np.array([2, 4, 6, 8, 10]),\n... index=['a', 'b', 'c', 'd', 'e'])\n>>> pd.cut(s, [0, 2, 4, 6, 8, 10], labels=False, retbins=True, right=False)\n... # doctest: +ELLIPSIS\n(a 1.0\n b 2.0\n c 3.0\n d 4.0\n e NaN\n dtype: float64,\n array([ 0, 2, 4, 6, 8, 10]))\n\nUse `drop` optional when bins is not unique\n\n>>> pd.cut(s, [0, 2, 4, 6, 10, 10], labels=False, retbins=True,\n... right=False, duplicates='drop')\n... # doctest: +ELLIPSIS\n(a 1.0\n b 2.0\n c 3.0\n d 3.0\n e NaN\n dtype: float64,\n array([ 0, 2, 4, 6, 10]))\n\nPassing an IntervalIndex for `bins` results in those categories exactly.\nNotice that values not covered by the IntervalIndex are set to NaN. 0\nis to the left of the first bin (which is closed on the right), and 1.5\nfalls between two bins.\n\n>>> bins = pd.IntervalIndex.from_tuples([(0, 1), (2, 3), (4, 5)])\n>>> pd.cut([0, 0.5, 1.5, 2.5, 4.5], bins)\n[NaN, (0.0, 1.0], NaN, (2.0, 3.0], (4.0, 5.0]]\nCategories (3, interval[int64, right]): [(0, 1] < (2, 3] < (4, 5]]\n\u001b[1;31mFile:\u001b[0m d:\\users\\phu.le2\\anaconda3\\lib\\site-packages\\pandas\\core\\reshape\\tile.py\n\u001b[1;31mType:\u001b[0m function\n" ], [ "frame = pd.DataFrame({'data1': np.random.randn(1000),\r\n 'data2': np.random.randn(1000)})\r\nquartiles = pd.cut(frame.data1, 4) #@P: cut the data1 to 4 group (not equal)\r\nquartiles[:10]", "_____no_output_____" ] ], [ [ "The `Categorical object` `returned by cut` can be passed directly to groupby. So we could compute a set of statistics for the data2 column like so:", "_____no_output_____" ] ], [ [ "#@P vietsub: get_stats is to obtain min, max, count, mean of the group\r\ndef get_stats(group):\r\n return {'min': group.min(), 'max': group.max(),\r\n 'count': group.count(), 'mean': group.mean()}\r\ngrouped = frame.data2.groupby(quartiles)\r\ngrouped.apply(get_stats).unstack()", "_____no_output_____" ] ], [ [ "These were equal-length buckets; to `compute equal-size buckets based on sample quantiles`, use `qcut`. I’ll pass labels=False to just get quantile numbers:", "_____no_output_____" ] ], [ [ "pd.qcut??", "\u001b[1;31mSignature:\u001b[0m\n\u001b[0mpd\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mqcut\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mq\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mretbins\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mprecision\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mint\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mduplicates\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'raise'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;31mSource:\u001b[0m \n\u001b[1;32mdef\u001b[0m \u001b[0mqcut\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mq\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mretbins\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mbool\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mFalse\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mprecision\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mint\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mduplicates\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mstr\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m\"raise\"\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[1;34m\"\"\"\n Quantile-based discretization function.\n\n Discretize variable into equal-sized buckets based on rank or based\n on sample quantiles. For example 1000 values for 10 quantiles would\n produce a Categorical object indicating quantile membership for each data point.\n\n Parameters\n ----------\n x : 1d ndarray or Series\n q : int or list-like of float\n Number of quantiles. 10 for deciles, 4 for quartiles, etc. Alternately\n array of quantiles, e.g. [0, .25, .5, .75, 1.] for quartiles.\n labels : array or False, default None\n Used as labels for the resulting bins. Must be of the same length as\n the resulting bins. If False, return only integer indicators of the\n bins. If True, raises an error.\n retbins : bool, optional\n Whether to return the (bins, labels) or not. Can be useful if bins\n is given as a scalar.\n precision : int, optional\n The precision at which to store and display the bins labels.\n duplicates : {default 'raise', 'drop'}, optional\n If bin edges are not unique, raise ValueError or drop non-uniques.\n\n Returns\n -------\n out : Categorical or Series or array of integers if labels is False\n The return type (Categorical or Series) depends on the input: a Series\n of type category if input is a Series else Categorical. Bins are\n represented as categories when categorical data is returned.\n bins : ndarray of floats\n Returned only if `retbins` is True.\n\n Notes\n -----\n Out of bounds values will be NA in the resulting Categorical object\n\n Examples\n --------\n >>> pd.qcut(range(5), 4)\n ... # doctest: +ELLIPSIS\n [(-0.001, 1.0], (-0.001, 1.0], (1.0, 2.0], (2.0, 3.0], (3.0, 4.0]]\n Categories (4, interval[float64, right]): [(-0.001, 1.0] < (1.0, 2.0] ...\n\n >>> pd.qcut(range(5), 3, labels=[\"good\", \"medium\", \"bad\"])\n ... # doctest: +SKIP\n [good, good, medium, bad, bad]\n Categories (3, object): [good < medium < bad]\n\n >>> pd.qcut(range(5), 4, labels=False)\n array([0, 0, 1, 2, 3])\n \"\"\"\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0moriginal\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_preprocess_for_cut\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_coerce_to_type\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\n\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[1;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mq\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mquantiles\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mlinspace\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mq\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mquantiles\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mq\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mbins\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0malgos\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mquantile\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mquantiles\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mfac\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbins\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0m_bins_to_cuts\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mbins\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mlabels\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mlabels\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mprecision\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mprecision\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0minclude_lowest\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mTrue\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[0mduplicates\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mduplicates\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[1;33m)\u001b[0m\u001b[1;33m\n\u001b[0m\u001b[1;33m\n\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[0m_postprocess_for_cut\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfac\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mbins\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mretbins\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0moriginal\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;31mFile:\u001b[0m d:\\users\\phu.le2\\anaconda3\\lib\\site-packages\\pandas\\core\\reshape\\tile.py\n\u001b[1;31mType:\u001b[0m function\n" ], [ "# Return quantile numbers\r\ngrouping = pd.qcut(frame.data1, 10, labels=False) #cut data1 to 10 equal group\r\ngrouped = frame.data2.groupby(grouping)\r\ngrouped.apply(get_stats).unstack()", "_____no_output_____" ] ], [ [ "### 10.3.3. Example: Filling Missing Values with Group-Specific Values", "_____no_output_____" ], [ "When cleaning up missing data, in some cases you will replace data observations using dropna, but in others you may want to impute (fill in) the null (NA) values using a fixed value or some value derived from the data. `fillna is the right tool to use`;<br>\r\nfor example, here I fill in NA values with the mean:", "_____no_output_____" ] ], [ [ "s = pd.Series(np.random.randn(6))\r\ns[::2] = np.nan\r\ns\r\ns.fillna(s.mean())", "_____no_output_____" ] ], [ [ "`Suppose you need the fill value to vary by group`. One way to do this is to group the data and use apply with a function that calls fillna on each data chunk. Here is some sample data on US states divided into eastern and western regions:", "_____no_output_____" ] ], [ [ "states = ['Ohio', 'New York', 'Vermont', 'Florida',\r\n 'Oregon', 'Nevada', 'California', 'Idaho']\r\ngroup_key = ['East'] * 4 + ['West'] * 4\r\ndata = pd.Series(np.random.randn(8), index=states)\r\ndata", "_____no_output_____" ] ], [ [ "Note that the syntax ['East'] * 4 produces a list containing four copies of the elements in ['East']. Adding lists together concatenates them.<br>\r\nLet’s set some values in the data to be missing:", "_____no_output_____" ] ], [ [ "data[['Vermont', 'Nevada', 'Idaho']] = np.nan\r\ndata", "_____no_output_____" ], [ "data.groupby(group_key).mean()", "_____no_output_____" ] ], [ [ "We can fill the NA values using the group means like so:", "_____no_output_____" ] ], [ [ "fill_mean = lambda g: g.fillna(g.mean())\r\ndata.groupby(group_key).apply(fill_mean)", "_____no_output_____" ] ], [ [ "In another case, you might have predefined fill values in your code that vary by group. Since the groups have a `name` attribute set internally, we can use that:", "_____no_output_____" ] ], [ [ "fill_values = {'East': 0.5, 'West': -1}\r\nfill_func = lambda g: g.fillna(fill_values[g.name])\r\ndata.groupby(group_key).apply(fill_func)", "_____no_output_____" ] ], [ [ "### 10.3.4. Example: Random Sampling and Permutation", "_____no_output_____" ], [ "`Suppose you wanted to draw a random sample (with or without replacement) from a large dataset` for Monte Carlo simulation purposes or some other application. *There are a number of ways to perform the “draws”*; *here we use the sample method for Series*.", "_____no_output_____" ], [ "To demonstrate, here’s a way to construct a deck of English-style playing cards:", "_____no_output_____" ] ], [ [ "# Hearts, Spades, Clubs, Diamonds\r\nsuits = ['H', 'S', 'C', 'D']\r\ncard_val = (list(range(1, 11)) + [10] * 3) * 4 #@P: đoạn 10 *3 để thêm value cho J, K, Q = 10 như kết quả bên dưới\r\nbase_names = ['A'] + list(range(2, 11)) + ['J', 'K', 'Q']\r\ncards = []\r\nfor suit in ['H', 'S', 'C', 'D']:\r\n cards.extend(str(num) + suit for num in base_names)\r\n\r\ndeck = pd.Series(card_val, index=cards)\r\ndeck", "_____no_output_____" ] ], [ [ "So now we have a Series of length 52 whose index contains card names and values are the ones used in Blackjack and other games (to keep things simple, I just let the ace 'A' be 1):", "_____no_output_____" ] ], [ [ "deck[:20]", "_____no_output_____" ] ], [ [ "Now, based on what I said before, drawing a hand of five cards from the deck could be written as:", "_____no_output_____" ] ], [ [ "def draw(deck, n=5):\r\n return deck.sample(n)\r\ndraw(deck)", "_____no_output_____" ] ], [ [ "Suppose you wanted two random cards from each suit (@P: suits = ['H', 'S', 'C', 'D'] -- Hearts, Spades, Clubs, Diamonds). Because the suit is the last character of each card name, we can group based on this and use apply:", "_____no_output_____" ] ], [ [ "get_suit = lambda card: card[-1] # last letter is suit\r\ndeck.groupby(get_suit).apply(draw, n=2)", "_____no_output_____" ] ], [ [ "Alternatively, we could write:", "_____no_output_____" ] ], [ [ "deck.groupby(get_suit, group_keys=False).apply(draw, n=2)", "_____no_output_____" ] ], [ [ "### 10.3.5. Example: Group Weighted Average and Correlation", "_____no_output_____" ], [ "Under the split-apply-combine paradigm of `groupby`, operations between columns in a DataFrame or two Series, such as a group weighted average, are possible. As an example, take this dataset containing group keys, values, and some weights:", "_____no_output_____" ] ], [ [ "df = pd.DataFrame({'category': ['a', 'a', 'a', 'a',\r\n 'b', 'b', 'b', 'b'],\r\n 'data': np.random.randn(8),\r\n 'weights': np.random.rand(8)})\r\ndf", "_____no_output_____" ] ], [ [ "The group weighted average by `category` would then be:", "_____no_output_____" ] ], [ [ "grouped = df.groupby('category')\r\nget_wavg = lambda g: np.average(g['data'], weights=g['weights'])\r\ngrouped.apply(get_wavg)", "_____no_output_____" ] ], [ [ "As another example, consider a financial dataset originally obtained from Yahoo! Finance containing end-of-day prices for a few stocks and the S&P 500 index (the SPX symbol):", "_____no_output_____" ] ], [ [ "close_px = pd.read_csv('examples/stock_px_2.csv', parse_dates=True,\r\n index_col=0)\r\nclose_px.info()\r\nclose_px[-4:]", "<class 'pandas.core.frame.DataFrame'>\nDatetimeIndex: 2214 entries, 2003-01-02 to 2011-10-14\nData columns (total 4 columns):\n # Column Non-Null Count Dtype \n--- ------ -------------- ----- \n 0 AAPL 2214 non-null float64\n 1 MSFT 2214 non-null float64\n 2 XOM 2214 non-null float64\n 3 SPX 2214 non-null float64\ndtypes: float64(4)\nmemory usage: 86.5 KB\n" ] ], [ [ "One task of interest might be to compute a DataFrame consisting of the yearly correlations of daily returns (computed from percent changes) with SPX.<br> As one way to do this, we first create a function that computes the pairwise correlation of each column with the 'SPX' column:", "_____no_output_____" ] ], [ [ "spx_corr = lambda x: x.corrwith(x['SPX']) #@P 20210903: SPX: S&P500 Index", "_____no_output_____" ] ], [ [ "Next, we compute percent change on `close_px` using `pct_change`:", "_____no_output_____" ] ], [ [ "rets = close_px.pct_change().dropna()", "_____no_output_____" ] ], [ [ "Lastly, we group these percent changes by year, which can be extracted from each row label with a one-line function that returns the `year` attribute of each `datetime` label:", "_____no_output_____" ] ], [ [ "get_year = lambda x: x.year\r\nby_year = rets.groupby(get_year)\r\nby_year.apply(spx_corr)", "_____no_output_____" ] ], [ [ "You could also compute inter-column correlations. Here we compute the annual correlation between Apple and Microsoft:", "_____no_output_____" ] ], [ [ "by_year.apply(lambda g: g['AAPL'].corr(g['MSFT']))", "_____no_output_____" ] ], [ [ "### 10.3.6. Example: Group-Wise Linear Regression", "_____no_output_____" ], [ "In the same theme as the previous example, you can use `groupby` to perform more complex group-wise statistical analysis, as long as the function returns a pandas object or scalar value.<br>\r\nFor example, I can define the following `regress` function (using the `statsmodels` econometrics library), which executes an `ordinary least squares (OLS) regression` on each chunk of data:", "_____no_output_____" ] ], [ [ "import statsmodels.api as sm\r\ndef regress(data, yvar, xvars):\r\n Y = data[yvar]\r\n X = data[xvars]\r\n X['intercept'] = 1.\r\n result = sm.OLS(Y, X).fit()\r\n return result.params", "_____no_output_____" ] ], [ [ "Now, to run a yearly linear regression of *AAPL* on *SPX* returns, execute:", "_____no_output_____" ] ], [ [ "by_year.apply(regress, 'AAPL', ['SPX'])", "_____no_output_____" ] ], [ [ "## 10.4. Pivot Tables and Cross-Tabulation", "_____no_output_____" ], [ "A pivot table is a data summarization tool frequently found in spreadsheet programs and other data analysis software. It aggregates a table of data by one or more keys, arranging the data in a rectangle with some of the group keys along the rows and some along the columns. `Pivot tables in Python with pandas are made possible through the groupby facility described in this chapter combined with reshape operations utilizing hierarchical indexing`. DataFrame has a pivot_table method, and there is also a top-level pandas.pivot_table function. In addition to providing a convenience interface to groupby, pivot_table can add partial totals, also known as margins.", "_____no_output_____" ], [ "Returning to the *tipping dataset*, suppose you wanted to *compute a table of group means* (the default pivot_table aggregation type) arranged *by day and smoker* on the rows:", "_____no_output_____" ] ], [ [ "tips.pivot_table(index=['day', 'smoker'])", "_____no_output_____" ] ], [ [ "`This could have been produced with groupby directly`. Now, suppose we want to aggregate only *tip_pct* and *size*, and additionally group by time. I’ll put *smoker* in the table columns and *day* in the rows:", "_____no_output_____" ] ], [ [ "tips.pivot_table(['tip_pct', 'size'], index=['time', 'day'],\r\n columns='smoker')", "_____no_output_____" ] ], [ [ "We could augment this table to include partial totals by passing *margins=True*. This has the effect of *adding All row and column labels*, with corresponding values being the group statistics for all the data within a single tier:<br>\r\n#@P 20210903: it like a subtotal for each group in Excel pivotable? (P guess they use the term margin to indicate the subotal is put at the margin of the calculated table)", "_____no_output_____" ] ], [ [ "tips.pivot_table(['tip_pct', 'size'], index=['time', 'day'],\r\n columns='smoker', margins=True)", "_____no_output_____" ] ], [ [ "Here, the All values are means without taking into account smoker versus non-smoker (the All columns) or any of the two levels of grouping on the rows (the All row).", "_____no_output_____" ], [ "*To use a different aggregation function*, pass it to `aggfunc`. For example, *'count'* or *len* will give you a cross-tabulation (count or frequency) of group sizes:", "_____no_output_____" ] ], [ [ "tips.pivot_table('tip_pct', index=['time', 'smoker'], columns='day',\r\n aggfunc=len, margins=True)", "_____no_output_____" ] ], [ [ "If some combinations are empty (or otherwise NA), you may wish to pass a `fill_value`:", "_____no_output_____" ] ], [ [ "tips.pivot_table('tip_pct', index=['time', 'size', 'smoker'],\r\n columns='day', aggfunc='mean', fill_value=0)", "_____no_output_____" ] ], [ [ "### 10.4.1 Cross-Tabulations: Crosstab", "_____no_output_____" ], [ "A `cross-tabulation` (or `crosstab` for short) is *a special case* of a pivot table that computes group frequencies. Here is an example:", "_____no_output_____" ] ], [ [ "from io import StringIO\r\ndata = \"\"\"\\\r\nSample Nationality Handedness\r\n1 USA Right-handed\r\n2 Japan Left-handed\r\n3 USA Right-handed\r\n4 Japan Right-handed\r\n5 Japan Left-handed\r\n6 Japan Right-handed\r\n7 USA Right-handed\r\n8 USA Left-handed\r\n9 Japan Right-handed\r\n10 USA Right-handed\"\"\"\r\ndata = pd.read_table(StringIO(data), sep='\\s+')", "_____no_output_____" ], [ "data", "_____no_output_____" ] ], [ [ "As part of some survey analysis, we might want to summarize this data by nationality and handedness. *You could use pivot_table to do this*, but the `pandas.crosstab function` can be more convenient:", "_____no_output_____" ] ], [ [ "pd.crosstab(data.Nationality, data.Handedness, margins=True)", "_____no_output_____" ] ], [ [ "*The first two arguments to crosstab *can each either `be an array` or `Series` or `a list of arrays`. As in the tips data:", "_____no_output_____" ] ], [ [ "pd.crosstab([tips.time, tips.day], tips.smoker, margins=True)", "_____no_output_____" ], [ "pd.options.display.max_rows = PREVIOUS_MAX_ROWS", "_____no_output_____" ] ], [ [ "## 10.5. Conclusion", "_____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", "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", "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", "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" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "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" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# 区域卷积神经网络（R-CNN）系列\n:label:`sec_rcnn`\n\n除了 :numref:`sec_ssd` 中描述的单发多框检测之外，\n区域卷积神经网络（region-based CNN或regions with CNN features，R-CNN） :cite:`Girshick.Donahue.Darrell.ea.2014` 也是将深度模型应用于目标检测的开创性工作之一。\n在本节中，我们将介绍R-CNN及其一系列改进方法：快速的R-CNN（Fast R-CNN） :cite:`Girshick.2015` 、更快的R-CNN（Faster R-CNN） :cite:`Ren.He.Girshick.ea.2015` 和掩码R-CNN（Mask R-CNN） :cite:`He.Gkioxari.Dollar.ea.2017` 。\n限于篇幅，我们只着重介绍这些模型的设计思路。 \n\n## R-CNN\n\n*R-CNN* 首先从输入图像中选取若干（例如2000个）*提议区域*（如锚框也是一种选取方法），并标注它们的类别和边界框（如偏移量）。 :cite:`Girshick.Donahue.Darrell.ea.2014` 然后，用卷积神经网络对每个提议区域进行前向计算以抽取其特征。\n接下来，我们用每个提议区域的特征来预测类别和边界框。 \n\n\n:label:`fig_r-cnn`\n\n:numref:`fig_r-cnn` 展示了R-CNN模型。具体来说，R-CNN包括以下四个步骤： \n\n1. 对输入图像使用 *选择性搜索* 来选取多个高质量的提议区域 :cite:`Uijlings.Van-De-Sande.Gevers.ea.2013` 。这些提议区域通常是在多个尺度下选取的，并具有不同的形状和大小。每个提议区域都将被标注类别和真实边界框。\n1. 选择一个预训练的卷积神经网络，并将其在输出层之前截断。将每个提议区域变形为网络需要的输入尺寸，并通过前向计算输出抽取的提议区域特征。 \n1. 将每个提议区域的特征连同其标注的类别作为一个样本。训练多个支持向量机对目标分类，其中每个支持向量机用来判断样本是否属于某一个类别。\n1. 将每个提议区域的特征连同其标注的边界框作为一个样本，训练线性回归模型来预测真实边界框。\n\n尽管 R-CNN 模型通过预训练的卷积神经网络有效地抽取了图像特征，但它的速度很慢。\n想象一下，我们可能从一张图像中选出上千个提议区域，这需要上千次的卷积神经网络的前向计算来执行目标检测。\n这种庞大的计算量使得 R-CNN 在现实世界中难以被广泛应用。 \n\n## Fast R-CNN\n\nR-CNN 的主要性能瓶颈在于，对每个提议区域，卷积神经网络的前向计算是独立的，而没有共享计算。\n由于这些区域通常有重叠，独立的特征抽取会导致重复的计算。\n*Fast R-CNN* :cite:`Girshick.2015` 对 R-CNN 的主要改进之一，是仅在整张图象上执行卷积神经网络的前向计算。 \n\n\n:label:`fig_fast_r-cnn`\n\n:numref:`fig_fast_r-cnn` 中描述了 Fast R-CNN 模型。它的主要计算如下： \n\n1. 与 R-CNN 相比，Fast R-CNN 用来提取特征的卷积神经网络的输入是整个图像，而不是各个提议区域。此外，这个网络通常会参与训练。设输入为一张图像，将卷积神经网络的输出的形状记为 $1 \\times c \\times h_1 \\times w_1$。\n1. 假设选择性搜索生成了$n$个提议区域。这些形状各异的提议区域在卷积神经网络的输出上分别标出了形状各异的兴趣区域。然后，这些感兴趣的区域需要进一步抽取出形状相同的特征（比如指定高度$h_2$和宽度$w_2$），以便于连结后输出。为了实现这一目标，Fast R-CNN 引入了 *兴趣区域 (RoI) 池化* 层：将卷积神经网络的输出和提议区域作为输入，输出连结后的各个提议区域抽取的特征，形状为$n \\times c \\times h_2 \\times w_2$。\n1. 通过全连接层将输出形状变换为$n \\times d$，其中超参数$d$取决于模型设计。\n1. 预测$n$个提议区域中每个区域的类别和边界框。更具体地说，在预测类别和边界框时，将全连接层的输出分别转换为形状为 $n \\times q$（$q$ 是类别的数量）的输出和形状为 $n \\times 4$ 的输出。其中预测类别时使用 softmax 回归。\n\n在Fast R-CNN 中提出的兴趣区域汇聚层与 :numref:`sec_pooling` 中介绍的汇聚层有所不同。在汇聚层中，我们通过设置池化窗口、填充和步幅的大小来间接控制输出形状。而兴趣区域汇聚层对每个区域的输出形状是可以直接指定的。 \n\n例如，指定每个区域输出的高和宽分别为 $h_2$ 和 $w_2$。\n对于任何形状为 $h \\times w$ 的兴趣区域窗口，该窗口将被划分为 $h_2 \\times w_2$ 子窗口网格，其中每个子窗口的大小约为$(h/h_2) \\times (w/w_2)$。\n在实践中，任何子窗口的高度和宽度都应向上取整，其中的最大元素作为该子窗口的输出。\n因此，兴趣区域汇聚层可从形状各异的兴趣区域中均抽取出形状相同的特征。\n\n作为说明性示例， :numref:`fig_roi` 中提到，在$4 \\times 4$的输入中，我们选取了左上角 $3\\times 3$ 的兴趣区域。\n对于该兴趣区域，我们通过 $2\\times 2$ 的兴趣区域汇聚层得到一个 $2\\times 2$ 的输出。\n请注意，四个划分后的子窗口中分别含有元素 0、1、4、5（5最大）；2、6（6最大）；8、9（9最大）；以及10。 \n\n\n:label:`fig_roi`\n\n下面，我们演示了兴趣区域汇聚层的计算方法。\n假设卷积神经网络抽取的特征 `X` 的高度和宽度都是 4，且只有单通道。\n", "_____no_output_____" ] ], [ [ "import torch\nimport torchvision\n\nX = torch.arange(16.).reshape(1, 1, 4, 4)\nX", "_____no_output_____" ] ], [ [ "让我们进一步假设输入图像的高度和宽度都是40像素，且选择性搜索在此图像上生成了两个提议区域。\n每个区域由5个元素表示：区域目标类别、左上角和右下角的 $(x, y)$ 坐标。\n", "_____no_output_____" ] ], [ [ "rois = torch.Tensor([[0, 0, 0, 20, 20], [0, 0, 10, 30, 30]])", "_____no_output_____" ] ], [ [ "由于 `X` 的高和宽是输入图像高和宽的 $1/10$，因此，两个提议区域的坐标先按 `spatial_scale` 乘以 0.1。\n然后，在 `X` 上分别标出这两个兴趣区域 `X[:, :, 1:4, 0:4]` 和 `X[:, :, 1:4, 0:4]` 。\n最后，在 $2\\times 2$ 的兴趣区域汇聚层中，每个兴趣区域被划分为子窗口网格，并进一步抽取相同形状 $2\\times 2$ 的特征。\n", "_____no_output_____" ] ], [ [ "torchvision.ops.roi_pool(X, rois, output_size=(2, 2), spatial_scale=0.1)", "_____no_output_____" ] ], [ [ "## Faster R-CNN\n\n为了较精确地检测目标结果，Fast R-CNN 模型通常需要在选择性搜索中生成大量的提议区域。\n*Faster R-CNN* :cite:`Ren.He.Girshick.ea.2015` 提出将选择性搜索替换为 *区域提议网络*（region proposal network），从而减少提议区域的生成数量，并保证目标检测的精度。 \n\n\n:label:`fig_faster_r-cnn`\n\n:numref:`fig_faster_r-cnn` 描述了Faster R-CNN 模型。\n与Fast R-CNN 相比，Faster R-CNN 只将生成提议区域的方法从选择性搜索改为了区域提议网络，模型的其余部分保持不变。具体来说，区域提议网络的计算步骤如下： \n\n1. 使用填充为1的 $3\\times 3$ 的卷积层变换卷积神经网络的输出，并将输出通道数记为 $c$。这样，卷积神经网络为图像抽取的特征图中的每个单元均得到一个长度为 $c$ 的新特征。\n1. 以特征图的每个像素为中心，生成多个不同大小和宽高比的锚框并标注它们。\n1. 使用锚框中心单元长度为 $c$ 的特征，分别预测该锚框的二元类别（含目标还是背景）和边界框。\n1. 使用非极大值抑制，从预测类别为目标的预测边界框中移除相似的结果。最终输出的预测边界框即是兴趣区域汇聚层所需的提议区域。\n\n值得一提的是，区域提议网络作为 Faster R-CNN 模型的一部分，是和整个模型一起训练得到的。\n换句话说，Faster R-CNN 的目标函数不仅包括目标检测中的类别和边界框预测，还包括区域提议网络中锚框的二元类别和边界框预测。\n作为端到端训练的结果，区域提议网络能够学习到如何生成高质量的提议区域，从而在减少了从数据中学习的提议区域的数量的情况下，仍保持目标检测的精度。 \n\n## Mask R-CNN\n\n如果在训练集中还标注了每个目标在图像上的像素级位置，那么 *Mask R-CNN* :cite:`He.Gkioxari.Dollar.ea.2017` 能够有效地利用这些详尽的标注信息进一步提升目标检测的精度。 \n\n\n:label:`fig_mask_r-cnn`\n\n如 :numref:`fig_mask_r-cnn` 所示，Mask R-CNN 是基于 Faster R-CNN 修改而来的。\n具体来说，Mask R-CNN 将兴趣区域汇聚层替换为了\n*兴趣区域 (RoI) 对齐* 层，使用 *双线性插值*（bilinear interpolation）来保留特征图上的空间信息，从而更适于像素级预测。\n兴趣区域对齐层的输出包含了所有与兴趣区域的形状相同的特征图。\n它们不仅被用于预测每个兴趣区域的类别和边界框，还通过额外的全卷积网络预测目标的像素级位置。\n本章的后续章节将更详细地介绍如何使用全卷积网络预测图像中像素级的语义。 \n\n## 小结\n\n* R-CNN 对图像选取若干提议区域，使用卷积神经网络对每个提议区域执行前向计算以抽取其特征，然后再用这些特征来预测提议区域的类别和边界框。\n* Fast R-CNN 对 R-CNN 的一个主要改进：只对整个图像做卷积神经网络的前向计算。它还引入了兴趣区域汇聚层，从而为具有不同形状的兴趣区域抽取相同形状的特征。\n* Faster R-CNN 将 Fast R-CNN 中使用的选择性搜索替换为参与训练的区域提议网络，这样后者可以在减少提议区域数量的情况下仍保证目标检测的精度。\n* Mask R-CNN 在 Faster R-CNN 的基础上引入了一个全卷积网络，从而借助目标的像素级位置进一步提升目标检测的精度。\n\n## 练习\n\n1. 我们能否将目标检测视为回归问题（例如预测边界框和类别的概率）？你可以参考 YOLO 模型 :cite:`Redmon.Divvala.Girshick.ea.2016` 的设计。\n1. 将单发多框检测与本节介绍的方法进行比较。他们的主要区别是什么？你可以参考 :cite:`Zhao.Zheng.Xu.ea.2019` 中的图2。\n", "_____no_output_____" ], [ "[讨论区](https://discuss.d2l.ai/t/3207)\n", "_____no_output_____" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Blending Problem\n## Problem definition", "_____no_output_____" ], [ "The Kahuna company manufactures sausages using three kinds of meat. The relevant information about the ingredients is provided in the table below:\n\n\n\n| Ingredient | Cost (€/kg) | Availability (kg) |\n|------------|--------------|-------------------|\n| Pork | 4.32 | 30 |\n| Wheat | 2.46 | 20 |\n| Starch | 1.86 | 17 |\n\nThe company makes two types of sausages:\n* Economy (>=40% Pork)\n* Premium (>=60% Pork)\n\nOne sausage is 50 grams (0.05 kg)\n\nAccording to government regulations, the most starch we can use in our sausages is 25%\n\nWe have a contract with a butcher, and have already purchased 23 kg pork, that will go bad if it's not used.\n\nWe have a demand for 350 economy sausages and 500 premium sausages.\n\n**Write a linear program to figure out the most cost effective recipe to manufacture our sausages.**\n\n\n## References ##\n[Introduction to Operations Research with Python](https://github.com/benalexkeen/Introduction-to-linear-programming)", "_____no_output_____" ] ] ]

[ "markdown" ]

[ [ "markdown", "markdown" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "from use_translator import *", "_____no_output_____" ], [ "qname = 'workflowB/B.1a_DILI-three-hop-from-disease-or-phenotypic-feature_trapi.json'", "_____no_output_____" ], [ "qfile = '/Users/bizon/Projects/SRI/minihackathons/2021-12_demo/'+qname", "_____no_output_____" ], [ "with open(qfile,'r') as inf:\n query = json.load(inf)\nprintjson(query)", "{\n \"message\": {\n \"query_graph\": {\n \"nodes\": {\n \"n0\": {\n \"ids\": [\n \"MONDO:0005359\"\n ],\n \"categories\": [\n \"biolink:DiseaseOrPhenotypicFeature\"\n ]\n },\n \"n1\": {\n \"categories\": [\n \"biolink:DiseaseOrPhenotypicFeature\"\n ]\n },\n \"n2\": {\n \"categories\": [\n \"biolink:Gene\"\n ]\n },\n \"n3\": {\n \"categories\": [\n \"biolink:ChemicalEntity\"\n ]\n }\n },\n \"edges\": {\n \"e01\": {\n \"subject\": \"n0\",\n \"object\": \"n1\",\n \"predicates\": [\n \"biolink:has_real_world_evidence_of_association_with\"\n ]\n },\n \"e02\": {\n \"subject\": \"n2\",\n \"object\": \"n1\",\n \"predicates\": [\n \"biolink:gene_associated_with_condition\"\n ]\n },\n \"e03\": {\n \"subject\": \"n2\",\n \"object\": \"n3\",\n \"predicates\": [\n \"biolink:related_to\"\n ]\n }\n }\n }\n }\n}\n" ], [ "sr = strider(query) ", "_____no_output_____" ], [ "arp = aragorn(query)", "_____no_output_____" ], [ "local_strider(query)", "_____no_output_____" ], [ "local_aragorn(query)", "_____no_output_____" ] ] ]

[ "code" ]

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

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Clean ZIMAS / zoning file\n* Dissolve zoning file so they are multipolygons\n* Use parser in `laplan.zoning` to parse ZONE_CMPLT\n* Manually list the failed to parse observations and fix\n* Use this to build crosswalk of height, density, etc restrictions", "_____no_output_____" ] ], [ [ "import boto3\nimport geopandas as gpd\nimport intake\nimport numpy as np\nimport os\nimport pandas as pd\nimport laplan\nimport utils", "_____no_output_____" ], [ "catalog = intake.open_catalog(\"../catalogs/*.yml\")\n\ns3 = boto3.client('s3')\nbucket_name = 'city-planning-entitlements'", "_____no_output_____" ], [ "# Default value of display.max_rows is 10 i.e. at max 10 rows will be printed.\n# Set it None to display all rows in the dataframe\npd.set_option('display.max_rows', 25)", "_____no_output_____" ], [ "# Dissolve zoning to get multipolygons\n# File is large, but we only care about unique ZONE_CMPLT, which need to be parsed\nzones = catalog.zoning.read()\nzones = zones[['ZONE_CMPLT', 'ZONE_SMRY', 'geometry']].assign(\n zone2 = zones.ZONE_CMPLT\n)\n\ndf = zones.dissolve(by='zone2').reset_index(drop=True)\ndf.head()", "_____no_output_____" ], [ "print(f'# obs in zoning: {len(zones)}')\nprint(f'# unique types of zoning: {len(df)}')", "# obs in zoning: 60588\n# unique types of zoning: 1934\n" ] ], [ [ "## Parse zoning string", "_____no_output_____" ] ], [ [ "parsed_col_names = ['Q', 'T', 'zone_class', 'specific_plan', 'height_district', 'D', 'overlay']\n\ndef parse_zoning(row):\n try:\n z = laplan.zoning.ZoningInfo(row.ZONE_CMPLT)\n return pd.Series([z.Q, z.T, z.zone_class, z.specific_plan, z.height_district, z.D, z.overlay], \n index = parsed_col_names)\n except ValueError:\n return pd.Series(['failed', 'failed', 'failed', 'failed', 'failed', 'failed', ''], \n index = parsed_col_names)\n\n \nparsed = df.apply(parse_zoning, axis = 1)\n\ndf = pd.concat([df, parsed], axis = 1)\n\ndf.head()", "_____no_output_____" ] ], [ [ "## Fix parse fails", "_____no_output_____" ] ], [ [ "fails_crosswalk = pd.read_parquet(f's3://{bucket_name}/data/crosswalk_zone_parse_fails.parquet')\n\nprint(f'# obs in fails_crosswalk: {len(fails_crosswalk)}')", "# obs in fails_crosswalk: 43\n" ], [ "# Grab all obs in our df that shows up in the fails_crosswalk, even if it was parsed correctly\n# There were some other ones that were added because they weren't valid zone classes\nfails = df[df.ZONE_CMPLT.isin(fails_crosswalk.ZONE_CMPLT)]\nprint(f'# obs in fails: {len(fails)}')", "# obs in fails: 43\n" ], [ "# Convert the overlay column from string to list\nfails_crosswalk.overlay = fails_crosswalk.overlay.str[1:-1].str.split(',').tolist()\n\n# Fill in Nones with empty list\nfails_crosswalk['overlay'] = fails_crosswalk['overlay'].apply(lambda row: row if isinstance(row, list) else [])", "_____no_output_____" ], [ "df1 = df[~ df.ZONE_CMPLT.isin(fails_crosswalk.ZONE_CMPLT)]\n\n# Append the successfully parsed obs with the failed ones\ndf2 = df1.append(fails_crosswalk)", "_____no_output_____" ], [ "# Make sure cols are the same type again\nfor col in ['zone_class', 'specific_plan', 'height_district']:\n df2[col] = df2[col].astype(str)\n\nfor col in ['Q', 'T', 'D']:\n df2[col] = df2[col].astype(int)", "_____no_output_____" ], [ "print(f'# obs in df: {len(df)}')\nprint(f'# obs in df2: {len(df2)}')", "# obs in df: 1934\n# obs in df2: 1934\n" ] ], [ [ "## Need to do something about overlays and specific plans...\n* leave as list? -> then split (ZONE_CMPLT, geometry) from the rest, so we can save geojson and tabular separately\n* GeoJSON can't take lists. Convert to strings...later make it a list again?", "_____no_output_____" ] ], [ [ "# Fill in Nones, otherwise cannot do the apply to make the list a string\ndf2.overlay = df2.overlay.fillna('')\n\njust_overlay = df2[df2.overlay != ''][['ZONE_CMPLT', 'overlay']]\njust_overlay['no_brackets'] = just_overlay['overlay'].apply(', '.join)", "_____no_output_____" ], [ "split = just_overlay.no_brackets.str.split(',', expand = True).fillna('')\nsplit.rename(columns = {0: 'o1', 1: 'o2', 2: 'o3'}, inplace = True)\n\njust_overlay = pd.concat([just_overlay, split], axis = 1)", "_____no_output_____" ], [ "supplemental_use = pd.read_parquet(f's3://{bucket_name}/data/crosswalk_supplemental_use_overlay.parquet')\nspecific_plan = pd.read_parquet(f's3://{bucket_name}/data/crosswalk_specific_plan.parquet')", "_____no_output_____" ], [ "supplemental_use_dict = supplemental_use.set_index('supplemental_use').to_dict()['supplemental_use_description']\nspecific_plan_dict = specific_plan.set_index('specific_plan').to_dict()['specific_plan_description']", "_____no_output_____" ], [ "# Trouble mapping it across all columns\nfor col in ['o1', 'o2', 'o3']:\n just_overlay[col] = just_overlay[col].str.strip()\n new_col = f'{col}_descrip'\n just_overlay[new_col] = just_overlay[col].map(supplemental_use_dict)\n just_overlay[new_col] = just_overlay[new_col].fillna('')", "_____no_output_____" ], [ "# Put df back together\ndf3 = pd.merge(df2, just_overlay, on = 'ZONE_CMPLT', how = 'left', validate = '1:1')\ndf3.head()", "_____no_output_____" ], [ "# Invalid overlays\n# What is SP? Specific Plan?\n# Also, can't find H", "_____no_output_____" ] ], [ [ "## Merge and export", "_____no_output_____" ] ], [ [ "col_order = ['ZONE_CMPLT', 'ZONE_SMRY', \n 'Q', 'T', 'zone_class', 'height_district', 'D',\n 'specific_plan', 'no_brackets', 'geometry']\n\n# Geometry is messed up, so let's get it back from original dissolve\nfinal = (pd.merge(df[['ZONE_CMPLT', 'geometry']], df3.drop(columns = \"geometry\"), \n on = \"ZONE_CMPLT\", how = \"left\", validate = \"1:1\")\n [col_order]\n .rename(columns = {'no_brackets': 'overlay'})\n .sort_values(['ZONE_CMPLT', 'ZONE_SMRY'])\n .reset_index(drop=True) \n )\n\nfinal.head()\n\n# Fix CRS. It's EPSG:2229, not EPSG:4326\nfinal.crs = \"EPSG:2229\"", "_____no_output_____" ], [ "file_name = 'gis/raw/parsed_zoning'\nutils.make_zipped_shapefile(final, f'../{file_name}')\n\ns3.upload_file(f'../{file_name}.zip', bucket_name, f'{file_name}.zip')", "Path name: ../gis/raw/parsed_zoning\nDirname (1st element of path): ../gis/raw/parsed_zoning\nShapefile name: parsed_zoning.shp\nShapefile component parts folder: ../gis/raw/parsed_zoning/parsed_zoning.shp\n" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import pandas as pd\nimport flair\nfrom bpemb import BPEmb\nfrom sklearn.feature_extraction.text import TfidfVectorizer\nfrom scipy.spatial.distance import cdist\nfrom sklearn.decomposition import TruncatedSVD\n#import spacy", "/home/londogard/miniconda3/envs/flair/lib/python3.9/site-packages/torch/cuda/__init__.py:52: UserWarning: CUDA initialization: Unexpected error from cudaGetDeviceCount(). Did you run some cuda functions before calling NumCudaDevices() that might have already set an error? Error 804: forward compatibility was attempted on non supported HW (Triggered internally at /opt/conda/conda-bld/pytorch_1607370151529/work/c10/cuda/CUDAFunctions.cpp:100.)\n return torch._C._cuda_getDeviceCount() > 0\n" ], [ "full_files_assignment = [f\"data/assignment/{x}/assignment.txt\" for x in os.listdir('data/assignment')]\nfull_files_data_assignment = [open(x).read() for x in full_files_assignment if not 'annot' in x and not '.DS' in x]", "_____no_output_____" ], [ "full_files = [f\"data/resumes/{x}\" for x in os.listdir('data/resumes')]\nfull_files_data = [open(x).read() for x in full_files]\n\nfull_files_data[0][:500]", "_____no_output_____" ], [ "vectorizer = TfidfVectorizer(stop_words='english', max_df=0.50, min_df=10)\nX = vectorizer.fit_transform(full_files_data+full_files_data_assignment)", "_____no_output_____" ], [ "X_assignment = X[1037:]\nX_resume= X[:1037]", "_____no_output_____" ], [ "dists = cdist(X_assignment[0].toarray(), X_resume.toarray(), metric='cosine')[0]\nidx = dists.argpartition(5)[:5]", "_____no_output_____" ], [ "idx", "_____no_output_____" ], [ "full_files_data[564][:500]", "_____no_output_____" ], [ "svd = TruncatedSVD(n_components=100)", "_____no_output_____" ], [ "X2=svd.fit_transform(X)", "_____no_output_____" ], [ "X_assignment = X2[1037:]\nX_resume= X2[:1037]", "_____no_output_____" ], [ "X_assignment.shape", "_____no_output_____" ], [ "dists = cdist(X_assignment[:1], X_resume, metric='cosine')[0]\nidx = dists.argpartition(5)[:5]", "_____no_output_____" ], [ "idx", "_____no_output_____" ], [ "dists[idx]", "_____no_output_____" ], [ "full_files[485]", "_____no_output_____" ], [ "#full_files_data_assignment[0]", "_____no_output_____" ], [ "dists[1:10]", "_____no_output_____" ] ] ]

[ "code" ]

[ [ "code", "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" ]

[ [ [ "# Flax Basics\n\nThis notebook will walk you through the following workflow:\n\n* Instantiating a model from Flax built-in layers or third-party models.\n* Initializing parameters of the model and manually written training.\n* Using optimizers provided by Flax to ease training.\n* Serialization of parameters and other objects.\n* Creating your own models and managing state.", "_____no_output_____" ], [ "## Setting up our environment\n\nHere we provide the code needed to set up the environment for our notebook.", "_____no_output_____" ] ], [ [ "# Install the latest JAXlib version.\n!pip install --upgrade -q pip jax jaxlib\n# Install Flax at head:\n!pip install --upgrade -q git+https://github.com/google/flax.git", "\u001b[33mWARNING: Running pip as root will break packages and permissions. You should install packages reliably by using venv: https://pip.pypa.io/warnings/venv\u001b[0m\n\u001b[33mWARNING: Running pip as root will break packages and permissions. You should install packages reliably by using venv: https://pip.pypa.io/warnings/venv\u001b[0m\n" ], [ "import jax\nfrom typing import Any, Callable, Sequence, Optional\nfrom jax import lax, random, numpy as jnp\nimport flax\nfrom flax.core import freeze, unfreeze\nfrom flax import linen as nn", "_____no_output_____" ] ], [ [ "## Linear regression with Flax\n\nIn the previous *JAX for the impatient* notebook, we finished up with a linear regression example. As we know, linear regression can also be written as a single dense neural network layer, which we will show in the following so that we can compare how it's done.\n\nA dense layer is a layer that has a kernel parameter $W\\in\\mathcal{M}_{m,n}(\\mathbb{R})$ where $m$ is the number of features as an output of the model, and $n$ the dimensionality of the input, and a bias parameter $b\\in\\mathbb{R}^m$. The dense layers returns $Wx+b$ from an input $x\\in\\mathbb{R}^n$.\n\nThis dense layer is already provided by Flax in the `flax.linen` module (here imported as `nn`).", "_____no_output_____" ] ], [ [ "# We create one dense layer instance (taking 'features' parameter as input)\nmodel = nn.Dense(features=5)", "_____no_output_____" ] ], [ [ "Layers (and models in general, we'll use that word from now on) are subclasses of the `linen.Module` class.\n\n### Model parameters & initialization\n\nParameters are not stored with the models themselves. You need to initialize parameters by calling the `init` function, using a PRNGKey and a dummy input parameter.", "_____no_output_____" ] ], [ [ "key1, key2 = random.split(random.PRNGKey(0))\nx = random.normal(key1, (10,)) # Dummy input\nparams = model.init(key2, x) # Initialization call\njax.tree_map(lambda x: x.shape, params) # Checking output shapes", "WARNING:absl:No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n" ] ], [ [ "*Note: JAX and Flax, like NumPy, are row-based systems, meaning that vectors are represented as row vectors and not column vectors. This can be seen in the shape of the kernel here.*\n\nThe result is what we expect: bias and kernel parameters of the correct size. Under the hood:\n\n* The dummy input variable `x` is used to trigger shape inference: we only declared the number of features we wanted in the output of the model, not the size of the input. Flax finds out by itself the correct size of the kernel.\n* The random PRNG key is used to trigger the initialization functions (those have default values provided by the module here).\n* Initialization functions are called to generate the initial set of parameters that the model will use. Those are functions that take as arguments `(PRNG Key, shape, dtype)` and return an Array of shape `shape`.\n* The init function returns the initialized set of parameters (you can also get the output of the evaluation on the dummy input with the same syntax but using the `init_with_output` method instead of `init`.", "_____no_output_____" ], [ "We see in the output that parameters are stored in a `FrozenDict` instance which helps deal with the functional nature of JAX by preventing any mutation of the underlying dict and making the user aware of it. Read more about it in the Flax docs. As a consequence, the following doesn't work:\n", "_____no_output_____" ] ], [ [ "try:\n params['new_key'] = jnp.ones((2,2))\nexcept ValueError as e:\n print(\"Error: \", e)", "Error: FrozenDict is immutable.\n" ] ], [ [ "To evaluate the model with a given set of parameters (never stored with the model), we just use the `apply` method by providing it the parameters to use as well as the input:", "_____no_output_____" ] ], [ [ "model.apply(params, x)", "_____no_output_____" ] ], [ [ "### Gradient descent\n\nIf you jumped here directly without going through the JAX part, here is the linear regression formulation we're going to use: from a set of data points $\\{(x_i,y_i), i\\in \\{1,\\ldots, k\\}, x_i\\in\\mathbb{R}^n,y_i\\in\\mathbb{R}^m\\}$, we try to find a set of parameters $W\\in \\mathcal{M}_{m,n}(\\mathbb{R}), b\\in\\mathbb{R}^m$ such that the function $f_{W,b}(x)=Wx+b$ minimizes the mean squared error:\n$$\\mathcal{L}(W,b)\\rightarrow\\frac{1}{k}\\sum_{i=1}^{k} \\frac{1}{2}\\|y_i-f_{W,b}(x_i)\\|^2_2$$\n\nHere, we see that the tuple $(W,b)$ matches the parameters of the Dense layer. We'll perform gradient descent using those. Let's first generate the fake data we'll use. The data is exactly the same as in the JAX part's linear regression pytree example.", "_____no_output_____" ] ], [ [ "# Set problem dimensions.\nn_samples = 20\nx_dim = 10\ny_dim = 5\n\n# Generate random ground truth W and b.\nkey = random.PRNGKey(0)\nk1, k2 = random.split(key)\nW = random.normal(k1, (x_dim, y_dim))\nb = random.normal(k2, (y_dim,))\n# Store the parameters in a pytree.\ntrue_params = freeze({'params': {'bias': b, 'kernel': W}})\n\n# Generate samples with additional noise.\nkey_sample, key_noise = random.split(k1)\nx_samples = random.normal(key_sample, (n_samples, x_dim))\ny_samples = jnp.dot(x_samples, W) + b + 0.1 * random.normal(key_noise,(n_samples, y_dim))\nprint('x shape:', x_samples.shape, '; y shape:', y_samples.shape)", "x shape: (20, 10) ; y shape: (20, 5)\n" ] ], [ [ "We copy the same training loop that we used in the JAX pytree linear regression example with `jax.value_and_grad()`, but here we can use `model.apply()` instead of having to define our own feed-forward function (`predict_pytree()` in the JAX example).", "_____no_output_____" ] ], [ [ "# Same as JAX version but using model.apply().\ndef mse(params, x_batched, y_batched):\n # Define the squared loss for a single pair (x,y)\n def squared_error(x, y):\n pred = model.apply(params, x)\n return jnp.inner(y-pred, y-pred) / 2.0\n # Vectorize the previous to compute the average of the loss on all samples.\n return jnp.mean(jax.vmap(squared_error)(x_batched,y_batched), axis=0)", "_____no_output_____" ] ], [ [ "And finally perform the gradient descent.", "_____no_output_____" ] ], [ [ "learning_rate = 0.3 # Gradient step size.\nprint('Loss for \"true\" W,b: ', mse(true_params, x_samples, y_samples))\nloss_grad_fn = jax.value_and_grad(mse)\n\[email protected]\ndef update_params(params, learning_rate, grads):\n params = jax.tree_map(\n lambda p, g: p - learning_rate * g, params, grads)\n return params\n\nfor i in range(101):\n # Perform one gradient update.\n loss_val, grads = loss_grad_fn(params, x_samples, y_samples)\n params = update_params(params, learning_rate, grads)\n if i % 10 == 0:\n print(f'Loss step {i}: ', loss_val)", "Loss for \"true\" W,b: 0.023639778\nLoss step 0: 38.094772\nLoss step 10: 0.44692168\nLoss step 20: 0.10053458\nLoss step 30: 0.035822745\nLoss step 40: 0.018846875\nLoss step 50: 0.013864839\nLoss step 60: 0.012312559\nLoss step 70: 0.011812928\nLoss step 80: 0.011649306\nLoss step 90: 0.011595251\nLoss step 100: 0.0115773035\n" ] ], [ [ "### Optimizing with Optax\n\nFlax used to use its own `flax.optim` package for optimization, but with\n[FLIP #1009](https://github.com/google/flax/blob/main/docs/flip/1009-optimizer-api.md)\nthis was deprecated in favor of\n[Optax](https://github.com/deepmind/optax).\n\nBasic usage of Optax is straightforward:\n\n1. Choose an optimization method (e.g. `optax.sgd`).\n2. Create optimizer state from parameters.\n3. Compute the gradients of your loss with `jax.value_and_grad()`.\n4. At every iteration, call the Optax `update` function to update the internal\n optimizer state and create an update to the parameters. Then add the update\n to the parameters with Optax's `apply_updates` method.\n\nNote that Optax can do a lot more: it's designed for composing simple gradient\ntransformations into more complex transformations that allows to implement a\nwide range of optimizers. There is also support for changing optimizer\nhyperparameters over time (\"schedules\"), applying different updates to different\nparts of the parameter tree (\"masking\") and much more. For details please refer\nto the\n[official documentation](https://optax.readthedocs.io/en/latest/).", "_____no_output_____" ] ], [ [ "import optax\ntx = optax.sgd(learning_rate=learning_rate)\nopt_state = tx.init(params)\nloss_grad_fn = jax.value_and_grad(mse)", "_____no_output_____" ], [ "for i in range(101):\n loss_val, grads = loss_grad_fn(params, x_samples, y_samples)\n updates, opt_state = tx.update(grads, opt_state)\n params = optax.apply_updates(params, updates)\n if i % 10 == 0:\n print('Loss step {}: '.format(i), loss_val)", "Loss step 0: 0.011576377\nLoss step 10: 0.0115710115\nLoss step 20: 0.011569244\nLoss step 30: 0.011568661\nLoss step 40: 0.011568454\nLoss step 50: 0.011568379\nLoss step 60: 0.011568358\nLoss step 70: 0.01156836\nLoss step 80: 0.01156835\nLoss step 90: 0.011568353\nLoss step 100: 0.011568348\n" ] ], [ [ "### Serializing the result\n\nNow that we're happy with the result of our training, we might want to save the model parameters to load them back later. Flax provides a serialization package to enable you to do that.", "_____no_output_____" ] ], [ [ "from flax import serialization\nbytes_output = serialization.to_bytes(params)\ndict_output = serialization.to_state_dict(params)\nprint('Dict output')\nprint(dict_output)\nprint('Bytes output')\nprint(bytes_output)", "Dict output\n{'params': {'bias': DeviceArray([-1.4540135, -2.0262308, 2.0806582, 1.2201802, -0.9964547], dtype=float32), 'kernel': DeviceArray([[ 1.0106664 , 0.19014716, 0.04533899, -0.92722285,\n 0.34720102],\n [ 1.7320251 , 0.9901233 , 1.1662225 , 1.1027892 ,\n -0.10574618],\n [-1.2009128 , 0.28837162, 1.4176372 , 0.12073109,\n -1.3132601 ],\n [-1.1944956 , -0.18993308, 0.03379077, 1.3165942 ,\n 0.07996067],\n [ 0.14103189, 1.3737966 , -1.3162128 , 0.53401774,\n -2.239638 ],\n [ 0.5643044 , 0.813604 , 0.31888172, 0.5359193 ,\n 0.90352124],\n [-0.37948322, 1.7408353 , 1.0788013 , -0.5041964 ,\n 0.9286919 ],\n [ 0.9701384 , -1.3158673 , 0.33630812, 0.80941117,\n -1.202457 ],\n [ 1.0198247 , -0.6198277 , 1.0822718 , -1.8385581 ,\n -0.45790705],\n [-0.64384323, 0.4564892 , -1.1331053 , -0.68556863,\n 0.17010891]], dtype=float32)}}\nBytes output\nb'\\x81\\xa6params\\x82\\xa4bias\\xc7!\\x01\\x93\\x91\\x05\\xa7float32\\xc4\\x14\\x1d\\x1d\\xba\\xbf\\xc4\\xad\\x01\\xc0\\x81)\\x05@\\xdd.\\x9c?\\xa8\\x17\\x7f\\xbf\\xa6kernel\\xc7\\xd6\\x01\\x93\\x92\\n\\x05\\xa7float32\\xc4\\xc8\\x84]\\x81?\\xf0\\xb5B>`\\xb59=z^m\\xbfU\\xc4\\xb1>\\x00\\xb3\\xdd?\\xb8x}?\\xc7F\\x95?2(\\x8d?t\\x91\\xd8\\xbd\\x83\\xb7\\x99\\xbfr\\xa5\\x93>#u\\xb5?\\xdcA\\xf7=\\xe8\\x18\\xa8\\xbf;\\xe5\\x98\\xbf\\xd1}B\\xbe0h\\n=)\\x86\\xa8?k\\xc2\\xa3=\\xaaj\\x10>\\x91\\xd8\\xaf?\\xa9y\\xa8\\xbfc\\xb5\\x08?;V\\x0f\\xc0Av\\x10?ZHP?wD\\xa3>\\x022\\t?+Mg?\\xa0K\\xc2\\xbe\\xb1\\xd3\\xde?)\\x16\\x8a?\\x04\\x13\\x01\\xbf\\xc1\\xbem?\\xfdZx?Wn\\xa8\\xbf\\x940\\xac>\\x925O?\\x1c\\xea\\x99\\xbf\\x9e\\x89\\x82?\\x07\\xad\\x1e\\xbf\\xe2\\x87\\x8a?\\xdfU\\xeb\\xbf\\xcbr\\xea\\xbe\\xe9\\xd2$\\xbf\\xf4\\xb8\\xe9>\\x98\\t\\x91\\xbfm\\x81/\\xbf\\x081.>'\n" ] ], [ [ "To load the model back, you'll need to use as a template the model parameter structure, like the one you would get from the model initialization. Here, we use the previously generated `params` as a template. Note that this will produce a new variable structure, and not mutate in-place.\n\n*The point of enforcing structure through template is to avoid users issues downstream, so you need to first have the right model that generates the parameters structure.*", "_____no_output_____" ] ], [ [ "serialization.from_bytes(params, bytes_output)", "_____no_output_____" ] ], [ [ "## Defining your own models\n\nFlax allows you to define your own models, which should be a bit more complicated than a linear regression. In this section, we'll show you how to build simple models. To do so, you'll need to create subclasses of the base `nn.Module` class.\n\n*Keep in mind that we imported* `linen as nn` *and this only works with the new linen API*", "_____no_output_____" ], [ "### Module basics\n\nThe base abstraction for models is the `nn.Module` class, and every type of predefined layers in Flax (like the previous `Dense`) is a subclass of `nn.Module`. Let's take a look and start by defining a simple but custom multi-layer perceptron i.e. a sequence of Dense layers interleaved with calls to a non-linear activation function.", "_____no_output_____" ] ], [ [ "class ExplicitMLP(nn.Module):\n features: Sequence[int]\n\n def setup(self):\n # we automatically know what to do with lists, dicts of submodules\n self.layers = [nn.Dense(feat) for feat in self.features]\n # for single submodules, we would just write:\n # self.layer1 = nn.Dense(feat1)\n\n def __call__(self, inputs):\n x = inputs\n for i, lyr in enumerate(self.layers):\n x = lyr(x)\n if i != len(self.layers) - 1:\n x = nn.relu(x)\n return x\n\nkey1, key2 = random.split(random.PRNGKey(0), 2)\nx = random.uniform(key1, (4,4))\n\nmodel = ExplicitMLP(features=[3,4,5])\nparams = model.init(key2, x)\ny = model.apply(params, x)\n\nprint('initialized parameter shapes:\\n', jax.tree_map(jnp.shape, unfreeze(params)))\nprint('output:\\n', y)", "initialized parameter shapes:\n {'params': {'layers_0': {'bias': (3,), 'kernel': (4, 3)}, 'layers_1': {'bias': (4,), 'kernel': (3, 4)}, 'layers_2': {'bias': (5,), 'kernel': (4, 5)}}}\noutput:\n [[ 4.2292815e-02 -4.3807115e-02 2.9323792e-02 6.5492536e-03\n -1.7147182e-02]\n [ 1.2967806e-01 -1.4551792e-01 9.4432183e-02 1.2521387e-02\n -4.5417298e-02]\n [ 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n 0.0000000e+00]\n [ 9.3024032e-04 2.7864395e-05 2.4478821e-04 8.1344310e-04\n -1.0110770e-03]]\n" ] ], [ [ "As we can see, a `nn.Module` subclass is made of:\n\n* A collection of data fields (`nn.Module` are Python dataclasses) - here we only have the `features` field of type `Sequence[int]`.\n* A `setup()` method that is being called at the end of the `__postinit__` where you can register submodules, variables, parameters you will need in your model.\n* A `__call__` function that returns the output of the model from a given input.\n* The model structure defines a pytree of parameters following the same tree structure as the model: the params tree contains one `layers_n` sub dict per layer, and each of those contain the parameters of the associated Dense layer. The layout is very explicit.\n\n*Note: lists are mostly managed as you would expect (WIP), there are corner cases you should be aware of as pointed out* [here](https://github.com/google/flax/issues/524)\n\nSince the module structure and its parameters are not tied to each other, you can't directly call `model(x)` on a given input as it will return an error. The `__call__` function is being wrapped up in the `apply` one, which is the one to call on an input:", "_____no_output_____" ] ], [ [ "try:\n y = model(x) # Returns an error\nexcept AttributeError as e:\n print(e)", "\"ExplicitMLP\" object has no attribute \"layers\"\n" ] ], [ [ "Since here we have a very simple model, we could have used an alternative (but equivalent) way of declaring the submodules inline in the `__call__` using the `@nn.compact` annotation like so:", "_____no_output_____" ] ], [ [ "class SimpleMLP(nn.Module):\n features: Sequence[int]\n\n @nn.compact\n def __call__(self, inputs):\n x = inputs\n for i, feat in enumerate(self.features):\n x = nn.Dense(feat, name=f'layers_{i}')(x)\n if i != len(self.features) - 1:\n x = nn.relu(x)\n # providing a name is optional though!\n # the default autonames would be \"Dense_0\", \"Dense_1\", ...\n return x\n\nkey1, key2 = random.split(random.PRNGKey(0), 2)\nx = random.uniform(key1, (4,4))\n\nmodel = SimpleMLP(features=[3,4,5])\nparams = model.init(key2, x)\ny = model.apply(params, x)\n\nprint('initialized parameter shapes:\\n', jax.tree_map(jnp.shape, unfreeze(params)))\nprint('output:\\n', y)", "initialized parameter shapes:\n {'params': {'layers_0': {'bias': (3,), 'kernel': (4, 3)}, 'layers_1': {'bias': (4,), 'kernel': (3, 4)}, 'layers_2': {'bias': (5,), 'kernel': (4, 5)}}}\noutput:\n [[ 4.2292815e-02 -4.3807115e-02 2.9323792e-02 6.5492536e-03\n -1.7147182e-02]\n [ 1.2967806e-01 -1.4551792e-01 9.4432183e-02 1.2521387e-02\n -4.5417298e-02]\n [ 0.0000000e+00 0.0000000e+00 0.0000000e+00 0.0000000e+00\n 0.0000000e+00]\n [ 9.3024032e-04 2.7864395e-05 2.4478821e-04 8.1344310e-04\n -1.0110770e-03]]\n" ] ], [ [ "There are, however, a few differences you should be aware of between the two declaration modes:\n\n* In `setup`, you are able to name some sublayers and keep them around for further use (e.g. encoder/decoder methods in autoencoders).\n* If you want to have multiple methods, then you **need** to declare the module using `setup`, as the `@nn.compact` annotation only allows one method to be annotated.\n* The last initialization will be handled differently. See these notes for more details (TODO: add notes link).\n", "_____no_output_____" ], [ "### Module parameters\n\nIn the previous MLP example, we relied only on predefined layers and operators (`Dense`, `relu`). Let's imagine that you didn't have a Dense layer provided by Flax and you wanted to write it on your own. Here is what it would look like using the `@nn.compact` way to declare a new modules:", "_____no_output_____" ] ], [ [ "class SimpleDense(nn.Module):\n features: int\n kernel_init: Callable = nn.initializers.lecun_normal()\n bias_init: Callable = nn.initializers.zeros\n\n @nn.compact\n def __call__(self, inputs):\n kernel = self.param('kernel',\n self.kernel_init, # Initialization function\n (inputs.shape[-1], self.features)) # shape info.\n y = lax.dot_general(inputs, kernel,\n (((inputs.ndim - 1,), (0,)), ((), ())),) # TODO Why not jnp.dot?\n bias = self.param('bias', self.bias_init, (self.features,))\n y = y + bias\n return y\n\nkey1, key2 = random.split(random.PRNGKey(0), 2)\nx = random.uniform(key1, (4,4))\n\nmodel = SimpleDense(features=3)\nparams = model.init(key2, x)\ny = model.apply(params, x)\n\nprint('initialized parameters:\\n', params)\nprint('output:\\n', y)", "initialized parameters:\n FrozenDict({\n params: {\n kernel: DeviceArray([[ 0.6503669 , 0.86789787, 0.4604268 ],\n [ 0.05673932, 0.9909285 , -0.63536596],\n [ 0.76134115, -0.3250529 , -0.65221626],\n [-0.82430327, 0.4150194 , 0.19405058]], dtype=float32),\n bias: DeviceArray([0., 0., 0.], dtype=float32),\n },\n})\noutput:\n [[ 0.5035518 1.8548558 -0.4270195 ]\n [ 0.0279097 0.5589246 -0.43061772]\n [ 0.3547128 1.5740999 -0.32865518]\n [ 0.5264864 1.2928858 0.10089308]]\n" ] ], [ [ "Here, we see how to both declare and assign a parameter to the model using the `self.param` method. It takes as input `(name, init_fn, *init_args)` : \n\n* `name` is simply the name of the parameter that will end up in the parameter structure.\n* `init_fn` is a function with input `(PRNGKey, *init_args)` returning an Array, with `init_args` being the arguments needed to call the initialisation function.\n* `init_args` are the arguments to provide to the initialization function.\n\nSuch params can also be declared in the `setup` method; it won't be able to use shape inference because Flax is using lazy initialization at the first call site.", "_____no_output_____" ], [ "### Variables and collections of variables\n\nAs we've seen so far, working with models means working with:\n\n* A subclass of `nn.Module`;\n* A pytree of parameters for the model (typically from `model.init()`);\n\nHowever this is not enough to cover everything that we would need for machine learning, especially neural networks. In some cases, you might want your neural network to keep track of some internal state while it runs (e.g. batch normalization layers). There is a way to declare variables beyond the parameters of the model with the `variable` method.\n\nFor demonstration purposes, we'll implement a simplified but similar mechanism to batch normalization: we'll store running averages and subtract those to the input at training time. For proper batchnorm, you should use (and look at) the implementation [here](https://github.com/google/flax/blob/main/flax/linen/normalization.py).", "_____no_output_____" ] ], [ [ "class BiasAdderWithRunningMean(nn.Module):\n decay: float = 0.99\n\n @nn.compact\n def __call__(self, x):\n # easy pattern to detect if we're initializing via empty variable tree\n is_initialized = self.has_variable('batch_stats', 'mean')\n ra_mean = self.variable('batch_stats', 'mean',\n lambda s: jnp.zeros(s),\n x.shape[1:])\n mean = ra_mean.value # This will either get the value or trigger init\n bias = self.param('bias', lambda rng, shape: jnp.zeros(shape), x.shape[1:])\n if is_initialized:\n ra_mean.value = self.decay * ra_mean.value + (1.0 - self.decay) * jnp.mean(x, axis=0, keepdims=True)\n\n return x - ra_mean.value + bias\n\n\nkey1, key2 = random.split(random.PRNGKey(0), 2)\nx = jnp.ones((10,5))\nmodel = BiasAdderWithRunningMean()\nvariables = model.init(key1, x)\nprint('initialized variables:\\n', variables)\ny, updated_state = model.apply(variables, x, mutable=['batch_stats'])\nprint('updated state:\\n', updated_state)", "initialized variables:\n FrozenDict({\n batch_stats: {\n mean: DeviceArray([0., 0., 0., 0., 0.], dtype=float32),\n },\n params: {\n bias: DeviceArray([0., 0., 0., 0., 0.], dtype=float32),\n },\n})\nupdated state:\n FrozenDict({\n batch_stats: {\n mean: DeviceArray([[0.01, 0.01, 0.01, 0.01, 0.01]], dtype=float32),\n },\n})\n" ] ], [ [ "Here, `updated_state` returns only the state variables that are being mutated by the model while applying it on data. To update the variables and get the new parameters of the model, we can use the following pattern:", "_____no_output_____" ] ], [ [ "for val in [1.0, 2.0, 3.0]:\n x = val * jnp.ones((10,5))\n y, updated_state = model.apply(variables, x, mutable=['batch_stats'])\n old_state, params = variables.pop('params')\n variables = freeze({'params': params, **updated_state})\n print('updated state:\\n', updated_state) # Shows only the mutable part", "updated state:\n FrozenDict({\n batch_stats: {\n mean: DeviceArray([[0.01, 0.01, 0.01, 0.01, 0.01]], dtype=float32),\n },\n})\nupdated state:\n FrozenDict({\n batch_stats: {\n mean: DeviceArray([[0.0299, 0.0299, 0.0299, 0.0299, 0.0299]], dtype=float32),\n },\n})\nupdated state:\n FrozenDict({\n batch_stats: {\n mean: DeviceArray([[0.059601, 0.059601, 0.059601, 0.059601, 0.059601]], dtype=float32),\n },\n})\n" ] ], [ [ "From this simplified example, you should be able to derive a full BatchNorm implementation, or any layer involving a state. To finish, let's add an optimizer to see how to play with both parameters updated by an optimizer and state variables.\n\n*This example isn't doing anything and is only for demonstration purposes.*", "_____no_output_____" ] ], [ [ "def update_step(tx, apply_fn, x, opt_state, params, state):\n\n def loss(params):\n y, updated_state = apply_fn({'params': params, **state},\n x, mutable=list(state.keys()))\n l = ((x - y) ** 2).sum()\n return l, updated_state\n\n (l, state), grads = jax.value_and_grad(loss, has_aux=True)(params)\n updates, opt_state = tx.update(grads, opt_state)\n params = optax.apply_updates(params, updates)\n return opt_state, params, state\n\nx = jnp.ones((10,5))\nvariables = model.init(random.PRNGKey(0), x)\nstate, params = variables.pop('params')\ndel variables\ntx = optax.sgd(learning_rate=0.02)\nopt_state = tx.init(params)\n\nfor _ in range(3):\n opt_state, params, state = update_step(tx, model.apply, x, opt_state, params, state)\n print('Updated state: ', state)", "Updated state: FrozenDict({\n batch_stats: {\n mean: DeviceArray([[0.01, 0.01, 0.01, 0.01, 0.01]], dtype=float32),\n },\n})\nUpdated state: FrozenDict({\n batch_stats: {\n mean: DeviceArray([[0.0199, 0.0199, 0.0199, 0.0199, 0.0199]], dtype=float32),\n },\n})\nUpdated state: FrozenDict({\n batch_stats: {\n mean: DeviceArray([[0.029701, 0.029701, 0.029701, 0.029701, 0.029701]], dtype=float32),\n },\n})\n" ] ], [ [ "Note that the above function has a quite verbose signature and it would not actually\nwork with `jax.jit()` because the function arguments are not \"valid JAX types\".\n\nWe provide a handy wrapper that simplifies the above code, see:\n\nhttps://flax.readthedocs.io/en/latest/flax.training.html#train-state", "_____no_output_____" ], [ "### Exporting to Tensorflow's SavedModel with jax2tf\n\nJAX released an experimental converter called [jax2tf](https://github.com/google/jax/tree/main/jax/experimental/jax2tf), which allows converting trained Flax models into Tensorflow's SavedModel format (so it can be used for [TF Hub](https://www.tensorflow.org/hub), [TF.lite](https://www.tensorflow.org/lite), [TF.js](https://www.tensorflow.org/js), or other downstream applications). The repository contains more documentation and has various examples for Flax.", "_____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" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ] ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ "BSD-2-Clause" ]

[ [ [ "import os\nimport argparse\nimport json\nimport shutil\n\nimport numpy as np\nimport torch\nimport skvideo.io\n\nfrom processor.io import IO\nimport tools\nimport tools.utils as utils\nimport tools.utils.visualization as visualization\nimport time", "_____no_output_____" ], [ "tt = time.time()\np = IO()", "Init Start\nself.get_parser finish\n" ], [ "p.model.eval()", "_____no_output_____" ], [ "%pwd", "_____no_output_____" ] ] ]

[ "code" ]

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# <b> SIRAH Candidate Pipeline Demo Notebook</b>\n<b>This notebook demostrates how to set up and run the SIRAH candidate pipeline and desribes its basic features</b> <br>\nby Mi Dai<br>\nApril 13, 2020<br>", "_____no_output_____" ], [ "## **0. prerequisites**", "_____no_output_____" ], [ "### **0.0 Before you start, follow the instructions under README [here](https://github.com/mi-dai/sirahtargets#pipeline-to-select-sirah-target) to set up conda enviroment and install other required packages**", "_____no_output_____" ], [ "### **0.1 Credentials**\nThe following credentials need to be obtained and set up in order to use all functions of the pipeline\n- **[alerce]**\n- **[lasair]** \n- **[TNS api key]**\n- **[SDSS CasJobs]** \n<br>\n\nIn the directory of this notebook\n`cp -r credentials_template/ credentials/` <br>\nThen fill in the credential info for each file.", "_____no_output_____" ], [ "### **0.2 local GLADE database**\nI have converted the downloaded GLADE catalogue into an sqlite3 database for easy query. <br>\nFor now you can grab the compiled database [here](https://www.dropbox.com/s/aib3ze9vaxmknp7/glade_v23.db?dl=0), and put it into a directory named `db/` in the directory of this notebook <br>\n(Later I will make sure the code that generates the db works so that you can make your own)", "_____no_output_____" ], [ "### **0.3 The following cells set up autoreload and import necessary packages for this notebook**", "_____no_output_____" ] ], [ [ "%load_ext autoreload\n%autoreload 2", "_____no_output_____" ], [ "import pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport os", "_____no_output_____" ] ], [ [ "### **0.4 Define the follow environment variables if you haven't done so**", "_____no_output_____" ] ], [ [ "os.environ['SFD_DIR'] = '/home/mi/sfddata-master' #modify this to point to the dust map downloaded from https://github.com/kbarbary/sfddata\nos.environ['SIRAHPIPE_DIR'] = os.getcwd() #Or your sirah_target_pipe dir if you are running in other directories", "_____no_output_____" ] ], [ [ "## **1. Using the pipeline**\n### **1.1 import the SIRAHPipe module first**", "_____no_output_____" ] ], [ [ "from pipeline import SIRAHPipe", "_____no_output_____" ] ], [ [ "### **1.2 initialize the pipeline** <a id='init_pipe'></a>\nThis cell defines the pipeline and chooses the brokers, crossmatch calalogues, and the selection cuts <br>\n**Currently implemented brokers:** \n[alerce](http://alerce.science/), \n[lasair](https://lasair.roe.ac.uk/streams/#),\n[tns](https://wis-tns.weizmann.ac.il/) <br>\n**Crossmatch catalogues:** \n[sdss](https://skyserver.sdss.org/CasJobs/SubmitJob.aspx),\n[ned](https://ned.ipac.caltech.edu/forms/nnd.html),\n[glade](http://glade.elte.hu/) <br>\n**Selection cuts:**\nzcut,\nztflimcut,\nhostdistcut,\nolddetectioncut,\nmagzcut,\nrbcut \n(see <a href='#run_pipe'>1.4 running the pipeline</a> for descriptions on the cuts)<br>\nFor this demo we select all of the above options:", "_____no_output_____" ] ], [ [ "pipe = SIRAHPipe(brokers=['alerce','lasair','tns'],xmatch_catalogues=['sdss','ned','glade'],\n selection_cuts=['zcut','ztflimcut','hostdistcut','olddetectioncut','magzcut','rbcut'])", "Setting up SkyServer...\nSetting up local db [db/glade_v23.db]\nBrokers to query: ['alerce', 'lasair', 'tns']\nCrossmatch catalogues: ['sdss', 'ned', 'glade']\nCuts to apply: ['zcut', 'ztflimcut', 'hostdistcut', 'olddetectioncut', 'magzcut', 'rbcut']\n" ] ], [ [ "### **1.3 using the realtime mode**\nLet's record current date and time. <br>\nThe pipeline can run in realtime or non-realtime mode. <br>\nif `realtime==True`, the sql query includes conditions on the latest magnitude provided by the brokers; <br>\nif `realtime==False`, the latest magnitudes are calculated offline by querying all the detections before the specific date.<br> This is to mimic realtime query but can be used for an earlier date for testing and comparing. Note that this may not produce the exact results as the real time mode as the broker databases may change. <br>\nFor this demo we set `realtime = True`", "_____no_output_____" ] ], [ [ "from astropy.time import Time\nfrom datetime import datetime\nprint(Time(datetime.today()),'mjd=',Time(datetime.today()).mjd)\nrealtime = True", "2020-04-22 18:13:58.102328 mjd= 58961.75970026116\n" ] ], [ [ "### **1.4 running the pipeline** <a id='run_pipe'></a>\nThis is the main part of the pipeline that many options can be specified. <br>\nHere I list some useful ones (and their default values): <br>\n- **[query options]** <br>\n - **mjdstart, mjdend:** mjd range to query\n - **gmax(=20.), rmax(=20.), gmin(=16.), rmin(=16.):** max/min magnitude ranges to query (ZTF specifically, for objects on TNS that are not ZTF the bands are hard code to be g at the moment)\n - **qlim:** number of objects to query for brokers (this is a universal number set for all brokers but currently not applied to tns) \n - **skip_ztf(=True):** set to True to skip importing TNS objects that has internal ZTF names (since it's already in the Alerce/Lasair queries) \n - **use_sherlock(=True):** include Lasair's sherlock classification and crossmatch results in query, default is True. This can be set to False in case sherlock is not available or for testing purpose\n<br> \n- **[selection cut options]** \n - **[zcut] zlow(=0.016), zhigh(=0.08), zerrlim(=0.02):** limit on redshift and redshift error, for specz the zerr is currently set to 0.001. Increase the number to include photoz results\n - **[magzcut] dmag_min(=1.), dmag_max(=4.5), magabs=(-19.1):** cut on the mag difference from a given absolute magnitude (peak mag for example) - this can be translated as phase cut if the sedmodel is known (see mag/z plot below). \n - **[rbcut] rb(=0.5):** real/bogus score for ZTF objects (higher rb value is more likely to be real)\n - **[hostdistcut] dist_min(=2.), dist_max(=None):** distance to host (in arcsec) \n - **[ztflimcut] maglim(=19.8), nobs(=1):** set mag lim for objects that has <= nobs detections. This is used to cut on single detections closer to the (ZTF) limiting mag\n - **[olddetectioncut] dayslim(=5), fromday(=None):** Remove objects whose latest detection is > *dayslim* days from *fromday* (These are potentially too old)\n<br>\n- **[other options]**\n - **[magz plot options]**\n - **sedmodel=('salt2'):** sedmodel to generate the mag vs z lines. This can be any sncosmo model listed [here](https://sncosmo.readthedocs.io/en/v2.1.x/source-list.html)\n - **sedmodel_pardict=(None):** dictionary of parameters to set for the sedmodel\n\n`pipe.run()` **runs the pipeline and applies the selection cuts defined in <a href='#init_pipe'>1.2 initialize the pipeline</a>, and makes a mag/z plot for the objects that passed all cuts. This may take a while (a few minutes to about less than an hour) depending on how large the query is and how many objects to be crossmatched.**", "_____no_output_____" ] ], [ [ "import time\ntoday = Time(datetime.today()).mjd\n\nstart = time.time()\npipe.run(mjdstart=today-10,mjdend=today,qlim=100,zerrlim=0.01,dmag_max=4.5,gmax=22,rmax=22,realtime=realtime,skip_ztf=True,use_sherlock=True)\n# pipe.run(mjdstart=today-10,mjdend=today,qlim=100,zerrlim=0.01,dmag_max=4.5,gmax=22,rmax=22,realtime=realtime,\n# skip_ztf=True,use_sherlock=True,sedmodel='s11-2005hl',magabs=-18)\nend = time.time()\nprint(\"Time used: {:.2f} mins\".format((end - start)/60.))", "queryresult size: 100\nqueryresult size: 100\nqueryresult size: 166\nTable [sncoor] uploaded successfully.\nQuery Job is submitted. JobID=47354091\nJob 47354091 is finished\nCross-matching GLADE catalog using astropy module search_around_sky\nDone. Time=0.021483612060546876 minutes\nCross match NED for 0.01 < sdss_photoz < 0.08, num = 2\nTable [sncoor] uploaded successfully.\nQuery Job is submitted. JobID=47354099\nJob 47354099 is finished\nCross-matching GLADE catalog using astropy module search_around_sky\nDone. Time=0.023793903986612956 minutes\nSelecting 0.016 < z < 0.080\n and zerr < 0.010\nNumber fails cut [flag_zcut]: 779/912\nCut on magnitude lim for nobs <= 1: maglim = 19.8\nNumber fails cut [flag_ztflimcut]: 14/912\nCut on distance to host: 2 < dist < None (Arcsec)\nNumber fails cut [flag_hostdistcut]: 113/912\nCut on days since last detection from 2020-04-22 18:16:02.215: dt < 5\nNumber fails cut [flag_olddetectioncut]: 459/912\n" ] ], [ [ "### **1.5 Miscellaneous features**\nHere I describe some miscellaneous features that may be useful in analyzing the query results", "_____no_output_____" ], [ "#### 1.5.1 *SIRAHPipe.results*\nAfter the pipeline runs, all the query results, including the selection cut flags, are saved in `SIRAHPipe.results`", "_____no_output_____" ] ], [ [ "pipe.results.head()", "_____no_output_____" ] ], [ [ "#### 1.5.2 the *SIRAHPipe.MakeCuts* module\n- **(re)applying cuts using** ***SIRAHPipe.MakeCuts.[Cutname]*** <br>\nThe `SIRAHPipe.MakeCuts` module contains all the selection cut functions that can be reapplied after the pipeline runs to change the selection criteria. <br>\ne.g. We can reapply the redshift cut with narrower `zerrlim=0.005` or apply new cuts that are not selected in the initialization phase <br>\n- **make mag/z plot using** ***SIRAHPipe.MakeCuts.plot()***\n- **return a pandas DataFrame for objects that passed all cuts using** ***SIRAHPipe.MakeCuts.aftercuts()*** <br>\nNote that `SIRAHPipe.MakeCuts.aftercuts()` returns all entries passing the cuts so there can be multiple entries for the same object. \nYou may use `pd.DataFrame.sort_values()` and `pd.DataFrame.drop_duplicates()` to select unique results or define your own ranking", "_____no_output_____" ] ], [ [ "## apply additional cut here \npipe.MakeCuts.zcut(zerrlim=0.005)\n# pipe.MakeCuts.olddetectioncut()\npipe.MakeCuts.magzcut(dmag_max=3.,dmag_min=0.,magabs=-18)\n# pipe.MakeCuts.ztflimcut()\npipe.MakeCuts.plot(magabs=-18,magz_plot=True,sedmodel='snana-2004fe',phase=[-10,-5,0])\n# pipe.MakeCuts.plot(magabs=-19,magz_plot=True)\nplt.show()\ndf = pipe.MakeCuts.aftercuts()\n\ncols = ['xmatch_rank','xmatch_db','distance']\nsort_cols = [x for x in cols if x in df.columns]\ndf = df.sort_values(sort_cols).drop_duplicates('oid')\ncols = ['oid','nobs','firstmjd','lastmjd','gmaglatest','rmaglatest','classearly','classification','distance','separationArcsec','dmag_g','dmag_r',\n 'z','zerr','xmatch_rank','objID','xmatch_objid','xmatch_table_name']\ncols_exist = [x for x in cols if x in df.columns]\ndf[cols_exist].head()", "Selecting 0.016 < z < 0.080\n and zerr < 0.005\nSelecting candidates based on mag vs z: 0.00 < dmag (from max) < 3.00\nPlotting MakeCuts...\n" ] ], [ [ "## **2. Making plots for selected candidates**", "_____no_output_____" ], [ "The main function for making light curve and phase estimate plots is *utils.gen_plots* <br>\n`gen_plots()` requires a pandas DataFrame as input that comes from running the pipeline or a self-defined `pd.DataFrame` that has the required columns as the pipeline results <br>\n- set **interactive = True** to make interactive plots in jupyter notebook (this doesn't seem to work with jupyter lab) <br>\n if interactive=True, the image will be an interactive Aladin widget; otherwise the image will be retrieved from the PS1 image server\n- set **savepdf = True** to out pdfs <br>\n currently the pdfs are plotted in the order of decreasing phase estimation\n\n**Here are some useful *gen_plots* options:** <br>\n- **magabs(=-19.1):** For Ia, \n- **extra_lc(=False):** set to *True* is extra photometry is available. The photometry need to be placed in `data/extra_photometry` as `[objectname].txt`\n- **update_lc_prediction(=False):** replot the lc prediction\n- **last_detection_max(=5):** don't include objects with last detection that is >5 days old\n- **source(='ztf'):** provide correct photometry format ('ztf' or 'tns')\n- **broker(='alerce'):** for ztf objects only, broker to query for light curve points ('alerce' or 'lasair')\n- **plot_ylim(=(21,15)):** ylims for the light curve and mag/z plots\n- **ps1_image_size(=320):** image size for PS1 images (in pixels), actual image size is 0.25 arcsec/pixel\n", "_____no_output_____" ] ], [ [ "from utils import *\nimport matplotlib.pyplot as plt\nimport os\nfrom PyPDF2 import PdfFileMerger\n# %matplotlib inline\n\ninteractive = False\nsavepdf = True\nquerydate = date.today()\nif not os.path.isdir('demo'):\n os.mkdir('demo')\n\nif savepdf:\n pdf_file = 'demo/Candidates_{}.pdf'.format(querydate.strftime(\"%m-%d-%Y\"))\n folder = 'demo/{}'.format(querydate.strftime(\"%m-%d-%Y\"))\n if not os.path.isdir(folder):\n os.mkdir(folder)\n pdflist = []\n orderlist = []\n# display(target[target.oid=='ZTF20aamfpft'])\nfor i,row in df[0:2].iterrows():\n if savepdf:\n f = '{}/{}.pdf'.format(folder,row.oid)\n else:\n f = None\n source = 'tns' if row['Broker'] == 'tns' else 'ztf'\n res = gen_plots(row,interactive=interactive,pdf_file=f,source=source,plot_ylim=(22,15),broker='lasair',\n sedmodel='salt2',magabs=-19.1)\n if savepdf and not res['too_old']:\n pdflist.append(f) \n orderlist.append(res['phase_tuesday'])\nif savepdf:\n idx_ordered = np.argsort(orderlist)\n merger = PdfFileMerger()\n for pdf in np.array(pdflist)[idx_ordered]:\n merger.append(pdf)\n merger.write(pdf_file)\n merger.close()", "ZTF20aaurfhs: z=0.0352 +/- 0.0010\nra = 17:01:22.507 dec = +20:18:58.35 mwebv=0.058\n" ] ] ]

[ "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", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# SageMaker Serverless Inference\n## XGBoost Regression Example\n\nAmazon SageMaker Serverless Inference is a purpose-built inference option that makes it easy for customers to deploy and scale ML models. Serverless Inference is ideal for workloads which have idle periods between traffic spurts and can tolerate cold starts. Serverless endpoints also automatically launch compute resources and scale them in and out depending on traffic, eliminating the need to choose instance types or manage scaling policies.\n\nFor this notebook we'll be working with the SageMaker XGBoost Algorithm to train a model and then deploy a serverless endpoint. We will be using the public S3 Abalone regression dataset for this example.\n\n<b>Notebook Setting</b>\n- <b>SageMaker Classic Notebook Instance</b>: ml.m5.xlarge Notebook Instance & conda_python3 Kernel\n- <b>SageMaker Studio</b>: Python 3 (Data Science)\n- <b>Regions Available</b>: SageMaker Serverless Inference is currently available in the following regions: US East (Northern Virginia), US East (Ohio), US West (Oregon), EU (Ireland), Asia Pacific (Tokyo) and Asia Pacific (Sydney)", "_____no_output_____" ], [ "## Table of Contents\n- Setup\n- Model Training\n- Deployment\n - Model Creation\n - Endpoint Configuration (Adjust for Serverless)\n - Serverless Endpoint Creation\n - Endpoint Invocation\n- Cleanup", "_____no_output_____" ], [ "## Setup\n\nFor testing you need to properly configure your Notebook Role to have <b>SageMaker Full Access</b>.", "_____no_output_____" ], [ "Let's start by installing preview wheels of the Python SDK, boto and aws cli", "_____no_output_____" ] ], [ [ "# Fallback in case wheels are unavailable\n! pip install sagemaker botocore boto3 awscli --upgrade", "_____no_output_____" ], [ "import subprocess\n\n\ndef execute_cmd(cmd):\n print(cmd)\n output = subprocess.getstatusoutput(cmd)\n return output\n\n\ndef _download_from_s3(_file_path):\n _path = f\"s3://reinvent21-sm-rc-wheels/{_file_path}\"\n print(f\"Path is {_path}\")\n ls_cmd = f\"aws s3 ls {_path}\"\n print(execute_cmd(ls_cmd))\n\n cmd = f\"aws s3 cp {_path} /tmp/\"\n print(\"Downloading: \", cmd)\n return execute_cmd(cmd)\n\n\ndef _install_wheel(wheel_name):\n cmd = f\"pip install --no-deps --log /tmp/output3.log /tmp/{wheel_name} --force-reinstall\"\n\n ret = execute_cmd(cmd)\n\n _name = wheel_name.split(\".\")[0]\n _, _version = execute_cmd(f\"python -c 'import {_name}; print({_name}.__version__)'\")\n\n for package in [\"botocore\", \"sagemaker\", \"boto3\", \"awscli\"]:\n print(execute_cmd(f\"python -c 'import {package}; print({package}.__version__)'\"))\n\n print(f\"Installed {_name}:{_version}\")\n\n return ret\n\n\ndef install_sm_py_sdk():\n pySDK_name = \"sagemaker.tar.gz\"\n\n exit_code, _ = _download_from_s3(\"dist/sagemaker.tar.gz\")\n\n if not exit_code:\n _install_wheel(pySDK_name)\n else:\n print(f\"'{pySDK_name}' is not present in S3 Bucket. Installing from public PyPi...\")\n execute_cmd(\"pip install sagemaker\")\n\n\ndef install_boto_wheels():\n WHEELS = [\"botocore.tar.gz\", \"boto3.tar.gz\", \"awscli.tar.gz\"]\n\n for wheel_name in WHEELS:\n _path = f\"boto3/{wheel_name}\"\n exit_code, _ = _download_from_s3(_path)\n\n if not exit_code:\n _install_wheel(wheel_name)\n else:\n print(f\"'{wheel_name}' is not present in S3 Bucket. Ignoring...\")\n\n\ninstall_boto_wheels()\ninstall_sm_py_sdk()", "_____no_output_____" ], [ "# Setup clients\nimport boto3\n\nclient = boto3.client(service_name=\"sagemaker\")\nruntime = boto3.client(service_name=\"sagemaker-runtime\")", "_____no_output_____" ] ], [ [ "### SageMaker Setup\nTo begin, we import the AWS SDK for Python (Boto3) and set up our environment, including an IAM role and an S3 bucket to store our data.", "_____no_output_____" ] ], [ [ "import boto3\nimport sagemaker\nfrom sagemaker.estimator import Estimator\n\nboto_session = boto3.session.Session()\nregion = boto_session.region_name\nprint(region)\n\nsagemaker_session = sagemaker.Session()\nbase_job_prefix = \"xgboost-example\"\nrole = sagemaker.get_execution_role()\nprint(role)\n\ndefault_bucket = sagemaker_session.default_bucket()\ns3_prefix = base_job_prefix\n\ntraining_instance_type = \"ml.m5.xlarge\"", "_____no_output_____" ] ], [ [ "Retrieve the Abalone dataset from a publicly hosted S3 bucket.", "_____no_output_____" ] ], [ [ "# retrieve data\n! curl https://sagemaker-sample-files.s3.amazonaws.com/datasets/tabular/uci_abalone/train_csv/abalone_dataset1_train.csv > abalone_dataset1_train.csv", "_____no_output_____" ] ], [ [ "Upload the Abalone dataset to the default S3 bucket.", "_____no_output_____" ] ], [ [ "# upload data to S3\n!aws s3 cp abalone_dataset1_train.csv s3://{default_bucket}/xgboost-regression/train.csv", "_____no_output_____" ] ], [ [ "## Model Training", "_____no_output_____" ], [ "Now, we train an ML model using the XGBoost Algorithm. In this example, we use a SageMaker-provided [XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) container image and configure an estimator to train our model.", "_____no_output_____" ] ], [ [ "from sagemaker.inputs import TrainingInput\n\ntraining_path = f\"s3://{default_bucket}/xgboost-regression/train.csv\"\ntrain_input = TrainingInput(training_path, content_type=\"text/csv\")", "_____no_output_____" ], [ "model_path = f\"s3://{default_bucket}/{s3_prefix}/xgb_model\"\n\n# retrieve xgboost image\nimage_uri = sagemaker.image_uris.retrieve(\n framework=\"xgboost\",\n region=region,\n version=\"1.0-1\",\n py_version=\"py3\",\n instance_type=training_instance_type,\n)\n\n# Configure Training Estimator\nxgb_train = Estimator(\n image_uri=image_uri,\n instance_type=training_instance_type,\n instance_count=1,\n output_path=model_path,\n sagemaker_session=sagemaker_session,\n role=role,\n)\n\n# Set Hyperparameters\nxgb_train.set_hyperparameters(\n objective=\"reg:linear\",\n num_round=50,\n max_depth=5,\n eta=0.2,\n gamma=4,\n min_child_weight=6,\n subsample=0.7,\n silent=0,\n)", "_____no_output_____" ] ], [ [ "Train the model on the Abalone dataset.", "_____no_output_____" ] ], [ [ "# Fit model\nxgb_train.fit({\"train\": train_input})", "_____no_output_____" ] ], [ [ "## Deployment", "_____no_output_____" ], [ "After training the model, retrieve the model artifacts so that we can deploy the model to an endpoint.", "_____no_output_____" ] ], [ [ "# Retrieve model data from training job\nmodel_artifacts = xgb_train.model_data\nmodel_artifacts", "_____no_output_____" ] ], [ [ "### Model Creation\nCreate a model by providing your model artifacts, the container image URI, environment variables for the container (if applicable), a model name, and the SageMaker IAM role.", "_____no_output_____" ] ], [ [ "from time import gmtime, strftime\n\nmodel_name = \"xgboost-serverless\" + strftime(\"%Y-%m-%d-%H-%M-%S\", gmtime())\nprint(\"Model name: \" + model_name)\n\n# dummy environment variables\nbyo_container_env_vars = {\"SAGEMAKER_CONTAINER_LOG_LEVEL\": \"20\", \"SOME_ENV_VAR\": \"myEnvVar\"}\n\ncreate_model_response = client.create_model(\n ModelName=model_name,\n Containers=[\n {\n \"Image\": image_uri,\n \"Mode\": \"SingleModel\",\n \"ModelDataUrl\": model_artifacts,\n \"Environment\": byo_container_env_vars,\n }\n ],\n ExecutionRoleArn=role,\n)\n\nprint(\"Model Arn: \" + create_model_response[\"ModelArn\"])", "_____no_output_____" ] ], [ [ "### Endpoint Configuration Creation\n\nThis is where you can adjust the <b>Serverless Configuration</b> for your endpoint. The current max concurrent invocations for a single endpoint, known as <b>MaxConcurrency</b>, can be any value from <b>1 to 50</b>, and <b>MemorySize</b> can be any of the following: <b>1024 MB, 2048 MB, 3072 MB, 4096 MB, 5120 MB, or 6144 MB</b>.", "_____no_output_____" ] ], [ [ "xgboost_epc_name = \"xgboost-serverless-epc\" + strftime(\"%Y-%m-%d-%H-%M-%S\", gmtime())\n\nendpoint_config_response = client.create_endpoint_config(\n EndpointConfigName=xgboost_epc_name,\n ProductionVariants=[\n {\n \"VariantName\": \"byoVariant\",\n \"ModelName\": model_name,\n \"ServerlessConfig\": {\n \"MemorySizeInMB\": 4096,\n \"MaxConcurrency\": 1,\n },\n },\n ],\n)\n\nprint(\"Endpoint Configuration Arn: \" + endpoint_config_response[\"EndpointConfigArn\"])", "_____no_output_____" ] ], [ [ "### Serverless Endpoint Creation\nNow that we have an endpoint configuration, we can create a serverless endpoint and deploy our model to it. When creating the endpoint, provide the name of your endpoint configuration and a name for the new endpoint.", "_____no_output_____" ] ], [ [ "endpoint_name = \"xgboost-serverless-ep\" + strftime(\"%Y-%m-%d-%H-%M-%S\", gmtime())\n\ncreate_endpoint_response = client.create_endpoint(\n EndpointName=endpoint_name,\n EndpointConfigName=xgboost_epc_name,\n)\n\nprint(\"Endpoint Arn: \" + create_endpoint_response[\"EndpointArn\"])", "_____no_output_____" ] ], [ [ "Wait until the endpoint status is InService before invoking the endpoint.", "_____no_output_____" ] ], [ [ "# wait for endpoint to reach a terminal state (InService) using describe endpoint\nimport time\n\ndescribe_endpoint_response = client.describe_endpoint(EndpointName=endpoint_name)\n\nwhile describe_endpoint_response[\"EndpointStatus\"] == \"Creating\":\n describe_endpoint_response = client.describe_endpoint(EndpointName=endpoint_name)\n print(describe_endpoint_response[\"EndpointStatus\"])\n time.sleep(15)\n\ndescribe_endpoint_response", "_____no_output_____" ] ], [ [ "### Endpoint Invocation\nInvoke the endpoint by sending a request to it. The following is a sample data point grabbed from the CSV file downloaded from the public Abalone dataset.", "_____no_output_____" ] ], [ [ "response = runtime.invoke_endpoint(\n EndpointName=endpoint_name,\n Body=b\".345,0.224414,.131102,0.042329,.279923,-0.110329,-0.099358,0.0\",\n ContentType=\"text/csv\",\n)\n\nprint(response[\"Body\"].read())", "_____no_output_____" ] ], [ [ "## Clean Up\nDelete any resources you created in this notebook that you no longer wish to use.", "_____no_output_____" ] ], [ [ "client.delete_model(ModelName=model_name)\nclient.delete_endpoint_config(EndpointConfigName=xgboost_epc_name)\nclient.delete_endpoint(EndpointName=endpoint_name)", "_____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", "markdown", "markdown", "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/ancka019/ComputationsMethods6sem/blob/main/method5.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ] ], [ [ "import numpy as np\nimport pandas as pd\nfrom numpy.linalg import eig\nfrom scipy.linalg import hilbert\nfrom copy import copy", "_____no_output_____" ] ], [ [ "Степенной метод", "_____no_output_____" ] ], [ [ "def pow_method(a,eps,x0=None):\n if x0 is None:\n x0 = np.random.uniform(-1,1,size=a.shape[1])\n x1 = a@x0\n num_of_iters = 1\n lambda0 = x1[0]/x0[0]\n while True:\n x0,x1 = x1, a@x1\n lambda1 = x1[0]/x0[0]\n if abs(lambda1-lambda0)<eps or num_of_iters > 5000:\n break\n lambda0 = lambda1\n num_of_iters += 1\n return abs(lambda1),num_of_iters", "_____no_output_____" ] ], [ [ "метод скалярных произведений", "_____no_output_____" ] ], [ [ "def scal_method(a,eps,x0=None): \n if x0 is None:\n x0 = np.random.uniform(-1,1,size=a.shape[1])\n num_of_iters = 1\n x1 = a@x0\n y0 = copy(x0)\n a_T = np.transpose(a)\n y1 = a_T@x0\n lambda0 = np.dot(x1,y1)/np.dot(x0,y0)\n while True:\n x0,x1 = x1, a@x1\n y0,y1 = y1, a_T@y1\n lambda1 = np.dot(x1,y1)/np.dot(x0,y1)\n if abs(lambda1-lambda0)<eps or num_of_iters > 5000:\n break\n lambda0 = lambda1\n num_of_iters += 1\n return abs(lambda1),num_of_iters", "_____no_output_____" ] ], [ [ "Решение\n", "_____no_output_____" ] ], [ [ "result = []\nfor size in [3,5,11]:\n A = hilbert(size)\n data = []\n lambda_acc = max(abs(np.linalg.eig(A)[0]))\n for eps in range(-6, -1):\n eps = 10**eps\n data.append({\n 'eps': eps,\n 'Степенной метод (К-во итераций)':\n pow_method(A, eps)[1],\n 'Степенной метод |lambda_acc - lambda|' : \n abs(lambda_acc - abs(pow_method(A, eps)[0])),\n 'Метод скалярных произведений (К-во итераций)':\n scal_method(A, eps)[1],\n 'Метод скалярных произведений |lambda_acc - lambda|' : \n abs(lambda_acc - abs(scal_method(A, eps)[0]))\n })\n result.append(pd.DataFrame(data))", "_____no_output_____" ], [ "result[0]", "_____no_output_____" ], [ "result[1]", "_____no_output_____" ], [ "result[2]", "_____no_output_____" ] ] ]

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

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

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "empty" ] ] ]

[ "empty" ]

[ [ "empty" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport os\nimport seaborn as sns\n\nelnino = pd.read_csv('tao-all2.dat', header=None, delimiter=' ')\noni = pd.read_csv('Data files/ONI.csv', header=0)\nelnino.columns = ['Observation', 'Year', 'Month', 'Day', 'Date', 'Latitude', 'Longitude', 'Zonal Winds',\n 'Meridional Winds', 'Humidity', 'Air Temp', 'Sea Surface Temp']", "_____no_output_____" ] ], [ [ "# Data Summary", "_____no_output_____" ] ], [ [ "elnino.head(20)", "_____no_output_____" ], [ "# Print statistical summary\nprint(\"Statistical summary for the 'Elnino' file: \\n\")\nprint(elnino.describe(), \"\\n \\n\")\n# display types for variables\nprint(\"The variable types are as follow: \\n\")\nprint(elnino.dtypes, \"\\n\")\n## get name of columns in dataset\nprint(\"The name of the columns in dataset are: \\n\")\nprint(elnino.columns, \"\\n\")\n## get number of rows and column in dataset\nprint(\"The dataset file is composed of the following number of rows and columns (rows, columns): \")\nprint(elnino.shape, \"\\n \\n\")\n# looking for null values\nprint(\"The total number of null/missing values before converting the variables is: \")\nprint(elnino.isnull().sum(), \"\\n\")\nprint(\"So, there is :\", elnino.isnull().values.sum(), \" value missing\")", "Statistical summary for the 'Elnino' file: \n\n Observation Year Month Day \\\ncount 178080.000000 178080.000000 178080.000000 178080.000000 \nmean 89040.500000 93.302325 6.504869 15.720536 \nstd 51407.412306 3.393818 3.459657 8.800487 \nmin 1.000000 80.000000 1.000000 1.000000 \n25% 44520.750000 92.000000 4.000000 8.000000 \n50% 89040.500000 94.000000 6.000000 16.000000 \n75% 133560.250000 96.000000 10.000000 23.000000 \nmax 178080.000000 98.000000 12.000000 31.000000 \n\n Date Latitude Longitude \ncount 178080.000000 178080.000000 178080.000000 \nmean 933689.455374 0.473626 -54.025233 \nstd 33900.474320 4.583041 135.363994 \nmin 800307.000000 -8.810000 -180.000000 \n25% 920116.000000 -2.010000 -154.950000 \n50% 940601.000000 0.010000 -111.260000 \n75% 960617.000000 4.980000 147.010000 \nmax 980623.000000 9.050000 171.080000 \n \n\nThe variable types are as follow: \n\nObservation int64\nYear int64\nMonth int64\nDay int64\nDate int64\nLatitude float64\nLongitude float64\nZonal Winds object\nMeridional Winds object\nHumidity object\nAir Temp object\nSea Surface Temp object\ndtype: object \n\nThe name of the columns in dataset are: \n\nIndex(['Observation', 'Year', 'Month', 'Day', 'Date', 'Latitude', 'Longitude',\n 'Zonal Winds', 'Meridional Winds', 'Humidity', 'Air Temp',\n 'Sea Surface Temp'],\n dtype='object') \n\nThe dataset file is composed of the following number of rows and columns (rows, columns): \n(178080, 12) \n \n\nThe total number of null/missing values before converting the variables is: \nObservation 0\nYear 0\nMonth 0\nDay 0\nDate 0\nLatitude 0\nLongitude 0\nZonal Winds 0\nMeridional Winds 0\nHumidity 0\nAir Temp 0\nSea Surface Temp 0\ndtype: int64 \n\nSo, there is : 0 value missing\n" ], [ "##\n# convert categorical variables to numeric\nelnino['Zonal Winds'] = pd.to_numeric(elnino['Zonal Winds'], errors='coerce')\nelnino['Meridional Winds'] = pd.to_numeric(elnino['Meridional Winds'], errors='coerce')\nelnino['Humidity'] = pd.to_numeric(elnino['Humidity'], errors='coerce')\nelnino['Air Temp'] = pd.to_numeric(elnino['Air Temp'], errors='coerce')\nelnino['Sea Surface Temp'] = pd.to_numeric(elnino['Sea Surface Temp'], errors='coerce')\n# display data types\nprint(\"After converting the variables, the new Data types are: \\n\", elnino.dtypes, \"\\n\")", "After converting the variables, the new Data types are: \n Observation int64\nYear int64\nMonth int64\nDay int64\nDate int64\nLatitude float64\nLongitude float64\nZonal Winds float64\nMeridional Winds float64\nHumidity float64\nAir Temp float64\nSea Surface Temp float64\ndtype: object \n\n" ], [ "elnino.describe().round(2)", "_____no_output_____" ], [ "# replace empty spaces with NAN values\nelnino.replace(r'^\\s*$', np.nan, regex=True)\nprint(\"The count of filled cells for each variable in the data set is: \\n\")\nprint(elnino.apply(lambda x: x.count(), axis=0), \"\\n \\n\")\nprint(\"The sum of filled cells in the data set is: \")\nprint(elnino.apply(lambda x: x.count(), axis=0).sum(), \"\\n \\n\")", "The count of filled cells for each variable in the data set is: \n\nObservation 178080\nYear 178080\nMonth 178080\nDay 178080\nDate 178080\nLatitude 178080\nLongitude 178080\nZonal Winds 152917\nMeridional Winds 152918\nHumidity 112319\nAir Temp 159843\nSea Surface Temp 161073\ndtype: int64 \n \n\nThe sum of filled cells in the data set is: \n1985630 \n \n\n" ], [ "elnino.apply(lambda x: x.count(), axis=0)", "_____no_output_____" ], [ "# print missing values per year\nelnino_Latitude = elnino['Latitude'].isnull().groupby(elnino['Year']).sum().astype(int).reset_index(name='Latitude')\nelnino_Longitude = elnino['Longitude'].isnull().groupby(elnino['Year']).sum().astype(int).reset_index(name='Longitude')\nelnino_Zonal_Winds = elnino['Zonal Winds'].isnull().groupby(elnino['Year']).sum().astype(int).reset_index(\n name='Zonal Winds')\nelnino_Meridional_Winds = elnino['Meridional Winds'].isnull().groupby(elnino['Year']).sum().astype(int).reset_index(\n name='Meridional Winds')\nelnino_Humidity = elnino['Humidity'].isnull().groupby(elnino['Year']).sum().astype(int).reset_index(name='Humidity')\nelnino_Air_Temp = elnino['Air Temp'].isnull().groupby(elnino['Year']).sum().astype(int).reset_index(name='Air Temp')\nelnino_Sea_Surface_Temp = elnino['Sea Surface Temp'].isnull().groupby(elnino['Year']).sum().astype(int).reset_index(\n name='Sea Surface Temp')\nelnino_1 = elnino_Latitude.join(elnino_Longitude.set_index('Year'), on='Year')\nelnino_2 = elnino_1.join(elnino_Zonal_Winds.set_index('Year'), on='Year')\nelnino_3 = elnino_2.join(elnino_Meridional_Winds.set_index('Year'), on='Year')\nelnino_4 = elnino_3.join(elnino_Humidity.set_index('Year'), on='Year')\nelnino_5 = elnino_4.join(elnino_Air_Temp.set_index('Year'), on='Year')\nelnino_6 = elnino_5.join(elnino_Sea_Surface_Temp.set_index('Year'), on='Year')\nprint(\"The total number of missing values per variable grouped by Year is: \", \"\\n\")\nelnino_6", "The total number of missing values per variable grouped by Year is: \n\n" ], [ "# looking for null values\nprint(\"The total number of null/missing values for each variable is: \", \"\\n\")\nprint(elnino.isnull().sum(), \"\\n\")\nprint(\"So, there is :\", elnino.isnull().values.sum(), \" value missing\", \"\\n \\n \\n \\n \\n\")\nprint(elnino.head(10))\nelnino_data_sum = elnino.apply(lambda x: x.count(), axis=0).sum()\nelnino_missing_sum = elnino.isnull().values.sum()\n# display percentage of missing data\nprint(\"The percentage of missing data is: \", \"\\n\")\nprint(str(round((elnino_missing_sum / elnino_data_sum) * 100, 2)), \"%\" \"\\n \\n \\n \\n\")\n# print correlation matrix\n# plt.figure(figsize=(12,12))\nplt.matshow(elnino.corr(), fignum=2)\nplt.title('Correlation Matrix El Nino')\nplt.colorbar()\nplt.gca().xaxis.tick_bottom()\nplt.xticks(range(12), list(elnino.columns), rotation='vertical')\nplt.yticks(range(12), list(elnino.columns))", "The total number of null/missing values for each variable is: \n\nObservation 0\nYear 0\nMonth 0\nDay 0\nDate 0\nLatitude 0\nLongitude 0\nZonal Winds 25163\nMeridional Winds 25162\nHumidity 65761\nAir Temp 18237\nSea Surface Temp 17007\ndtype: int64 \n\nSo, there is : 151330 value missing \n \n \n \n \n\n Observation Year Month Day Date Latitude Longitude Zonal Winds \\\n0 1 80 3 7 800307 -0.02 -109.46 -6.8 \n1 2 80 3 8 800308 -0.02 -109.46 -4.9 \n2 3 80 3 9 800309 -0.02 -109.46 -4.5 \n3 4 80 3 10 800310 -0.02 -109.46 -3.8 \n4 5 80 3 11 800311 -0.02 -109.46 -4.2 \n5 6 80 3 12 800312 -0.02 -109.46 -4.4 \n6 7 80 3 13 800313 -0.02 -109.46 -3.2 \n7 8 80 3 14 800314 -0.02 -109.46 -3.1 \n8 9 80 3 15 800315 -0.02 -109.46 -3.0 \n9 10 80 3 16 800316 -0.02 -109.46 -1.2 \n\n Meridional Winds Humidity Air Temp Sea Surface Temp \n0 0.7 NaN 26.14 26.24 \n1 1.1 NaN 25.66 25.97 \n2 2.2 NaN 25.69 25.28 \n3 1.9 NaN 25.57 24.31 \n4 1.5 NaN 25.30 23.19 \n5 0.3 NaN 24.72 23.64 \n6 0.1 NaN 24.66 24.34 \n7 0.6 NaN 25.17 24.14 \n8 1.0 NaN 25.59 24.24 \n9 1.0 NaN 26.71 25.94 \nThe percentage of missing data is: \n\n7.62 %\n \n \n \n\n" ], [ "elnino.drop(columns=['Observation']).corr().round(2)", "_____no_output_____" ], [ "elnino.hist(\n column=['Latitude', 'Longitude', 'Zonal Winds', 'Meridional Winds', 'Humidity', 'Air Temp', 'Sea Surface Temp'],\n figsize=(14, 14))", "_____no_output_____" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<table>\n <tr><td>\n <a href=\"https://nbviewer.jupyter.org/github/panayiotiska/Jupyter-Sentiment-Analysis-Video-games-reviews/blob/master/Vectorization.ipynb\">\n <img alt=\"start\" src=\"figures/button_previous.jpg\" width= 70% height= 70%>\n </td><td>\n <a href=\"https://nbviewer.jupyter.org/github/panayiotiska/Jupyter-Sentiment-Analysis-Video-games-reviews/blob/master/Index.ipynb\">\n <img alt=\"start\" src=\"figures/button_table-of-contents.jpg\" width= 70% height= 70%>\n </td><td>\n <a href=\"https://nbviewer.jupyter.org/github/panayiotiska/Jupyter-Sentiment-Analysis-Video-games-reviews/blob/master/Naive_Bayes_&_SVM_HashingVectorizer_Binary.ipynb\">\n <img alt=\"start\" src=\"figures/button_next.jpg\" width= 70% height= 70%>\n </td></tr>\n</table>", "_____no_output_____" ], [ "## Naive Bayes and Support vector machines using TF-IDF vectorizer\nIn this model both algorithms, Naive Bayes and Support Vector Machines are tested using the TF-IDF vectorizer, implemented in the scikit-learn's library. This vectorizer transforms a count matrix to a normalized tf-idf representation. Tf means term-frequency while tf-idf means term-frequency times inverse document-frequency. IDF is used to scale down the impact of tokens that occur very frequently in a given corpus and that are hence empirically less informative than features that occur in a small fraction of the training corpus.", "_____no_output_____" ] ], [ [ "import numpy as np\nimport matplotlib.pyplot as plt\nimport pandas as pd\nfrom nltk.tokenize import word_tokenize\nfrom nltk import pos_tag\nfrom nltk.corpus import stopwords\nfrom nltk.stem import WordNetLemmatizer\nfrom sklearn.preprocessing import LabelEncoder\nfrom collections import defaultdict\nfrom nltk.corpus import wordnet as wn\nfrom sklearn.feature_extraction.text import TfidfVectorizer\nfrom sklearn import model_selection, naive_bayes, svm\nfrom sklearn.metrics import accuracy_score\nfrom collections import Counter\n\n#[1] Importing dataset\n\ndataset = pd.read_json(r\"C:\\Users\\Panos\\Desktop\\Dissert\\Code\\Video_Games_5.json\", lines=True, encoding='latin-1')\ndataset = dataset[['reviewText','overall']]\n\n#[2] Reduce number of classes\n\nratings = []\nfor index,entry in enumerate(dataset['overall']):\n if entry == 1.0 or entry == 2.0:\n ratings.append(-1)\n elif entry == 3.0:\n ratings.append(0)\n elif entry == 4.0 or entry == 5.0:\n ratings.append(1)", "_____no_output_____" ], [ "#[3] Cleaning the text\n\nimport re\nimport nltk\nnltk.download('stopwords')\nfrom nltk.corpus import stopwords\n\ncorpus = []\nfor i in range(0, len(dataset)):\n review = re.sub('[^a-zA-Z]', ' ', dataset['reviewText'][i])\n review = review.lower()\n review = review.split()\n review = [word for word in review if not word in set(stopwords.words('english'))]\n review = ' '.join(review)\n corpus.append(review)", "[nltk_data] Downloading package stopwords to\n[nltk_data] C:\\Users\\Panos\\AppData\\Roaming\\nltk_data...\n[nltk_data] Package stopwords is already up-to-date!\n" ], [ "#[4] Prepare Train and Test Data sets\n \nTrain_X, Test_X, Train_Y, Test_Y = model_selection.train_test_split(corpus,ratings,test_size=0.3)\n\nprint(Counter(Train_Y).values()) # counts the elements' frequency", "dict_values([19749, 122618, 19879])\n" ], [ "#[5] Encoding\n\nEncoder = LabelEncoder()\nTrain_Y = Encoder.fit_transform(Train_Y)\nTest_Y = Encoder.fit_transform(Test_Y)", "_____no_output_____" ], [ "#[6] Word Vectorization\n \nTfidf_vect = TfidfVectorizer(max_features=10000)\nTfidf_vect.fit(corpus)\nTrain_X_Tfidf = Tfidf_vect.transform(Train_X)\nTest_X_Tfidf = Tfidf_vect.transform(Test_X)\n\n# the vocabulary that it has learned from the corpus\n#print(Tfidf_vect.vocabulary_)\n\n# the vectorized data\n#print(Train_X_Tfidf)", "_____no_output_____" ], [ "#[7] Use the Naive Bayes Algorithms to Predict the outcome\n\n# fit the training dataset on the NB classifier\nNaive = naive_bayes.MultinomialNB()\nNaive.fit(Train_X_Tfidf,Train_Y)\n# predict the labels on validation dataset\npredictions_NB = Naive.predict(Test_X_Tfidf)\n\n# Use accuracy_score function to get the accuracy\nprint(\"-----------------------Naive Bayes------------------------\\n\")\nprint(\"Naive Bayes Accuracy Score -> \",accuracy_score(predictions_NB, Test_Y)*100)\n# Making the confusion matrix\nfrom sklearn.metrics import confusion_matrix\ncm = confusion_matrix(Test_Y, predictions_NB)\nprint(\"\\n\",cm,\"\\n\")\n# Printing a classification report of different metrics\nfrom sklearn.metrics import classification_report\nmy_tags = ['Positive','Neutral','Negative']\nprint(classification_report(Test_Y, predictions_NB,target_names=my_tags))\n\n# Export reports to files for later visualizations\nreport_NB = classification_report(Test_Y, predictions_NB,target_names=my_tags, output_dict=True)\nreport_NB_df = pd.DataFrame(report_NB).transpose()\nreport_NB_df.to_csv(r'NB_report_TFIDFVect.csv', index = True, float_format=\"%.3f\")", "-----------------------Naive Bayes------------------------\n\nNaive Bayes Accuracy Score -> 77.46282394224409\n\n [[ 1544 120 6973]\n [ 174 118 8234]\n [ 121 49 52201]] \n\n precision recall f1-score support\n\n Positive 0.84 0.18 0.29 8637\n Neutral 0.41 0.01 0.03 8526\n Negative 0.77 1.00 0.87 52371\n\n accuracy 0.77 69534\n macro avg 0.68 0.40 0.40 69534\nweighted avg 0.74 0.77 0.70 69534\n\n" ], [ "#[8] Use the Support Vector Machine Algorithms to Predict the outcome\n\n# Classifier - Algorithm - SVM\n# fit the training dataset on the classifier\nSVM = svm.SVC(C=1.0, kernel='linear', degree=3, gamma='auto')\nSVM.fit(Train_X_Tfidf,Train_Y)\n# predict the labels on validation dataset\npredictions_SVM = SVM.predict(Test_X_Tfidf)\n\n# Use accuracy_score function to get the accuracy\nprint(\"-----------------Support Vector Machine CM------------------\\n\")\nprint(\"Accuracy Score -> \",accuracy_score(predictions_SVM, Test_Y)*100)\ncm = confusion_matrix(Test_Y, predictions_SVM)\n# Making the confusion matrix\nprint(\"\\n\",cm,\"\\n\")\n# Printing a classification report of different metrics\nprint(classification_report(Test_Y, predictions_SVM,target_names=my_tags))\n\n# Export reports to files for later visualizations\nreport_SVM = classification_report(Test_Y, predictions_SVM,target_names=my_tags, output_dict=True)\nreport_SVM_df = pd.DataFrame(report_SVM).transpose()\nreport_SVM_df.to_csv(r'SVM_report_TFIDFVect.csv', index = True, float_format=\"%.3f\")", "-----------------Support Vector Machine CM------------------\n\nAccuracy Score -> 82.27485834268128\n\n [[ 4993 761 2883]\n [ 1365 1399 5762]\n [ 880 674 50817]] \n\n precision recall f1-score support\n\n Positive 0.69 0.58 0.63 8637\n Neutral 0.49 0.16 0.25 8526\n Negative 0.85 0.97 0.91 52371\n\n accuracy 0.82 69534\n macro avg 0.68 0.57 0.59 69534\nweighted avg 0.79 0.82 0.79 69534\n\n" ] ], [ [ "<a href=\"https://nbviewer.jupyter.org/github/panayiotiska/Jupyter-Sentiment-Analysis-Video-games-reviews/blob/master/Naive_Bayes_&_SVM_HashingVectorizer_Binary.ipynb\">\n <img alt=\"start\" src=\"figures/button_next.jpg\">", "_____no_output_____" ] ] ]

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

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

[ "CC-BY-4.0" ]

[ "CC-BY-4.0" ]

[ "CC-BY-4.0" ]

[ [ [ "# CARTO frames workshop\n\nFull details at the [documentation](https://cartodb.github.io/cartoframes/) page. I'm using the `master` branch installed using\n\n```sh\npip install cartoframes jupyter seaborn\n```\n", "_____no_output_____" ] ], [ [ "import cartoframes\nfrom cartoframes import Credentials, CartoContext\nimport pandas as pd\nimport os", "_____no_output_____" ] ], [ [ "## Load the credentials", "_____no_output_____" ] ], [ [ "try:\n cc = cartoframes.CartoContext()\n print('Getting the credentials from a previous session')\nexcept Exception as e:\n print('Getting the credentials from your environment or here')\n BASEURL = os.environ.get('CARTO_API_URL','https://jsanz.carto.com') # <-- replace with your username or set up the envvar\n APIKEY = os.environ.get('CARTO_API_KEY',False) # <-- replace False with your CARTO API key or set up the envvar\n if BASEURL and APIKEY:\n creds = Credentials(base_url=BASEURL,key=APIKEY)\n creds.save()\n cc = cartoframes.CartoContext()\n else:\n print('Set up your environment!')\n ", "Getting the credentials from a previous session\n" ] ], [ [ "## Load the typical `Populated Places` dataset from CARTO", "_____no_output_____" ], [ "You can import this dataset from the Data Library", "_____no_output_____" ] ], [ [ "df = cc.read('populated_places')\ndf.head()", "_____no_output_____" ] ], [ [ "## It's a Pandas data frame\n\nYou can get the `featurecla` field counts", "_____no_output_____" ] ], [ [ "df.groupby('featurecla').featurecla.count()", "_____no_output_____" ] ], [ [ "## Run SQL queries", "_____no_output_____" ] ], [ [ "cc.query('''\nSELECT featurecla,count(*) as counts\nFROM populated_places\nGROUP BY featurecla\n''')", "_____no_output_____" ] ], [ [ "## Draw graphics using Seaborn\n\nMore about seaborn [here](https://seaborn.pydata.org/)", "_____no_output_____" ] ], [ [ "import seaborn as sns\nimport matplotlib.pyplot as plt\nimport warnings\nwarnings.filterwarnings('ignore')\n%matplotlib inline", "_____no_output_____" ], [ "f, ax = plt.subplots(figsize=(16, 6))\nsns.boxplot(x=\"featurecla\", y=\"pop_max\", data=df);", "_____no_output_____" ] ], [ [ "## Render your tables from CARTO", "_____no_output_____" ] ], [ [ "from cartoframes import Layer, styling\nl = Layer(\n 'populated_places', \n color={'column': 'featurecla','scheme': styling.prism(9)},\n size ={'column': 'pop_max','bin_method':'quantiles','bins' : 4, 'min': 3, 'max':10}\n)\ncc.map(layers=l, interactive=True)", "_____no_output_____" ] ], [ [ "## Render queries from CARTO", "_____no_output_____" ] ], [ [ "from cartoframes import QueryLayer\nlines = QueryLayer(\n '''\n WITH capitals as (\n select * \n from populated_places \n where featurecla like 'Admin-0 capital'\n )\n select pp.cartodb_id,\n pp.pop_max,\n ST_MakeLine(c.the_geom,pp.the_geom) as the_geom,\n ST_MakeLine(c.the_geom_webmercator,pp.the_geom_webmercator) as the_geom_webmercator\n from populated_places pp join capitals c on pp.adm0_a3 = c.adm0_a3\n where c.adm0_a3 = 'ESP'\n ''', \n color = {'column':'pop_max','scheme':styling.sunset(bins=3)},\n size ={'column': 'pop_max','bin_method':'quantiles','bins' : 4, 'min': 3, 'max':10}\n)\ncc.map(layers=lines, interactive=True,zoom=4, lat=36.19, lng=-6.79)", "_____no_output_____" ], [ "points = QueryLayer(\n '''\n select *\n from populated_places\n where adm0_a3 = 'ESP'\n ''', \n color = {'column':'pop_max','scheme':styling.sunset(bins=3)},\n size = {'column':'pop_max','bin_method':'quantiles','bins' : 4, 'min': 3, 'max':7}\n)\ncc.map(layers=[lines,points], interactive=True,zoom=4, lat=36.19, lng=-6.79)", "_____no_output_____" ] ], [ [ "## Crazy queries\n\nYou can render fancy queries, more details [here](https://gist.github.com/jsanz/8aeb48a274e3b787ca57)", "_____no_output_____" ] ], [ [ "query = '''\nwith -- first data\ndata as (\n SELECT * \n FROM jsanz.ne_10m_populated_places_simple_7 \n WHERE \n(megacity >= 0.5 AND megacity <= 1) AND featurecla IN ('Admin-0 capital','Admin-1 region capital','Admin-0 region capital','Admin-0 capital alt')\n), -- from dubai\norigin as (\n select *\n from jsanz.ne_10m_populated_places_simple_7\n where cartodb_id = 7263\n), -- cities closer to 14000 Km\ndests as (\n select d.*,\n ST_Distance(\n o.the_geom::geography,\n d.the_geom::geography\n )::int distance\n from data d, origin o\n where \n ST_DWithin( o.the_geom::geography, d.the_geom::geography, 14000000 ) \n),\ngeoms as (\n select \n dests.cartodb_id, dests.name, dests.adm0name, dests.distance,\n st_transform(\n st_segmentize(\n st_makeline(\n origin.the_geom,\n dests.the_geom\n )::geography,\n 10000\n )::geometry,\n 3857) the_geom_webmercator\n from origin,dests\n)\nselect *, st_transform(the_geom_webmercator,4326) as the_geom from geoms\n'''\ncc.map(QueryLayer(query), interactive=False, zoom=2, lat=19.9, lng=29.5)", "_____no_output_____" ] ], [ [ "## Create a new table on CARTO", "_____no_output_____" ] ], [ [ "df_spain = df[(df['adm0_a3'] == 'ESP')]\ndf_spain['name'].head()", "_____no_output_____" ], [ "cc.write(df_spain, 'places_spain', overwrite=True)", "Table successfully written to CARTO: https://jsanz.carto.com/dataset/places_spain\n" ], [ "cc.query('SELECT DISTINCT adm0_a3 FROM places_spain')", "_____no_output_____" ] ], [ [ "## Modify schema and data", "_____no_output_____" ], [ "Drop a column", "_____no_output_____" ] ], [ [ "df_spain = df[(df['adm0_a3'] == 'ESP')]\ndf_spain = df_spain.drop('adm0_a3', 1)\ncc.write(df_spain, 'places_spain', overwrite=True)", "Table successfully written to CARTO: https://jsanz.carto.com/dataset/places_spain\n" ], [ "try:\n cc.query('SELECT DISTINCT adm0_a3 FROM places_spain')\nexcept Exception as e:\n print(e)", "['column \"adm0_a3\" does not exist']\n" ] ], [ [ "Add `València` as an alternate name for the city of `Valencia`", "_____no_output_____" ] ], [ [ "vlc_id = df_spain[df.apply(lambda x: x['name'] == 'Valencia', axis=1)].index.values[0]\ndf_spain = df_spain.set_value(vlc_id,'cityalt','València')", "_____no_output_____" ], [ "# THE FUTURE\n# cc.sync(df_spain,'places_spain')\n\n# THE PRESENT\ncc.write(df_spain, 'places_spain', overwrite=True)", "Table successfully written to CARTO: https://jsanz.carto.com/dataset/places_spain\n" ], [ "cc.query('''SELECT name,cityalt from places_spain WHERE cartodb_id = {}'''.format(vlc_id))", "_____no_output_____" ] ], [ [ "## Delete the table", "_____no_output_____" ] ], [ [ "cc.delete('places_spain')", "_____no_output_____" ] ], [ [ "## But there's more\n\nTake a look into the documentation for other functions related with CARTO Data Observatory. All these features are is still under active development, things may change quickly.", "_____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" ]

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/ibnuhajar/TrainingMachineLearning/blob/main/TrainGridSearch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ] ], [ [ "import pandas as pd\nimport os \nimport numpy as np\nimport matplotlib.pyplot as plt\n\n\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.svm import SVR\n\nos.listdir('sample_data')\n\ndata = pd.read_csv('sample_data/Salary_Data.csv')\n\nX = data['YearsExperience']\ny = data['Salary']\nX = X[:,np.newaxis]\n\nmodel = SVR()\n\nparameters = {\n 'kernel' : ['rbf'],\n 'C' : [1000,10000,100000],\n 'gamma' : [0.5,0.05,0.005]\n}\n\ngrid_search = GridSearchCV(model,parameters)\ngrid_search.fit(X,y)", "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:18: FutureWarning: Support for multi-dimensional indexing (e.g. `obj[:, None]`) is deprecated and will be removed in a future version. Convert to a numpy array before indexing instead.\n" ], [ "print(grid_search.best_params_)", "{'C': 100000, 'gamma': 0.005, 'kernel': 'rbf'}\n" ], [ "model_baru = SVR(C=100000, gamma=0.005, kernel='rbf')\nmodel_baru.fit(X,y)", "_____no_output_____" ], [ "plt.scatter(X,y)\nplt.plot(X, model_baru.predict(X))", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Predict tags on StackOverflow with linear models", "_____no_output_____" ], [ "In this assignment you will learn how to predict tags for posts from [StackOverflow](https://stackoverflow.com). To solve this task you will use multilabel classification approach.\n\n### Libraries\n\nIn this task you will need the following libraries:\n- [Numpy](http://www.numpy.org) — a package for scientific computing.\n- [Pandas](https://pandas.pydata.org) — a library providing high-performance, easy-to-use data structures and data analysis tools for the Python\n- [scikit-learn](http://scikit-learn.org/stable/index.html) — a tool for data mining and data analysis.\n- [NLTK](http://www.nltk.org) — a platform to work with natural language.", "_____no_output_____" ], [ "### Data\n\nThe following cell will download all data required for this assignment into the folder `week1/data`.", "_____no_output_____" ] ], [ [ "! wget https://raw.githubusercontent.com/hse-aml/natural-language-processing/master/setup_google_colab.py -O setup_google_colab.py\nimport setup_google_colab\nsetup_google_colab.setup_week1()", "\nRedirecting output to ‘wget-log’.\n" ], [ "import sys\nsys.path.append(\"..\")\nfrom common.download_utils import download_week1_resources\n\ndownload_week1_resources()", "**************************************************\ntrain.tsv\n**************************************************\nvalidation.tsv\n**************************************************\ntest.tsv\n**************************************************\ntext_prepare_tests.tsv\n" ], [ "", "_____no_output_____" ] ], [ [ "### Grading\nWe will create a grader instance below and use it to collect your answers. Note that these outputs will be stored locally inside grader and will be uploaded to platform only after running submitting function in the last part of this assignment. If you want to make partial submission, you can run that cell any time you want.", "_____no_output_____" ] ], [ [ "from grader import Grader", "_____no_output_____" ], [ "grader = Grader()", "_____no_output_____" ] ], [ [ "### Text preprocessing", "_____no_output_____" ], [ "For this and most of the following assignments you will need to use a list of stop words. It can be downloaded from *nltk*:", "_____no_output_____" ] ], [ [ "import nltk\nnltk.download('stopwords')\nfrom nltk.corpus import stopwords", "[nltk_data] Downloading package stopwords to /root/nltk_data...\n[nltk_data] Unzipping corpora/stopwords.zip.\n" ] ], [ [ "In this task you will deal with a dataset of post titles from StackOverflow. You are provided a split to 3 sets: *train*, *validation* and *test*. All corpora (except for *test*) contain titles of the posts and corresponding tags (100 tags are available). The *test* set is provided for Coursera's grading and doesn't contain answers. Upload the corpora using *pandas* and look at the data:", "_____no_output_____" ] ], [ [ "from ast import literal_eval\nimport pandas as pd\nimport numpy as np", "_____no_output_____" ], [ "def read_data(filename):\n data = pd.read_csv(filename, sep='\\t')\n data['tags'] = data['tags'].apply(literal_eval)\n return data", "_____no_output_____" ], [ "train = read_data('data/train.tsv')\nvalidation = read_data('data/validation.tsv')\ntest = pd.read_csv('data/test.tsv', sep='\\t')", "_____no_output_____" ], [ "train.head()", "_____no_output_____" ] ], [ [ "As you can see, *title* column contains titles of the posts and *tags* column contains the tags. It could be noticed that a number of tags for a post is not fixed and could be as many as necessary.", "_____no_output_____" ], [ "For a more comfortable usage, initialize *X_train*, *X_val*, *X_test*, *y_train*, *y_val*.", "_____no_output_____" ] ], [ [ "X_train, y_train = train['title'].values, train['tags'].values\nX_val, y_val = validation['title'].values, validation['tags'].values\nX_test = test['title'].values", "_____no_output_____" ] ], [ [ "One of the most known difficulties when working with natural data is that it's unstructured. For example, if you use it \"as is\" and extract tokens just by splitting the titles by whitespaces, you will see that there are many \"weird\" tokens like *3.5?*, *\"Flip*, etc. To prevent the problems, it's usually useful to prepare the data somehow. In this task you'll write a function, which will be also used in the other assignments. \n\n**Task 1 (TextPrepare).** Implement the function *text_prepare* following the instructions. After that, run the function *test_test_prepare* to test it on tiny cases and submit it to Coursera.", "_____no_output_____" ] ], [ [ "import re", "_____no_output_____" ], [ "REPLACE_BY_SPACE_RE = re.compile('[/(){}\\[\\]\\|@,;]')\nBAD_SYMBOLS_RE = re.compile('[^0-9a-z #+_]')\nSTOPWORDS = set(stopwords.words('english'))\n\ndef text_prepare(text):\n \"\"\"\n text: a string\n \n return: modified initial string\n \"\"\"\n text = text.lower() # lowercase text\n text = re.sub(REPLACE_BY_SPACE_RE, \" \", text)# replace REPLACE_BY_SPACE_RE symbols by space in text\n text = re.sub(BAD_SYMBOLS_RE, \"\", text)# delete symbols which are in BAD_SYMBOLS_RE from text\n # print(text)\n text = ' '.join([word for word in text.split() if word not in STOPWORDS]) # Remove stopwords\n # print(text)\n text = text.strip()\n #text = re.sub(' +', ' ', text)\n # print(text)\n return text", "_____no_output_____" ], [ "def test_text_prepare():\n examples = [\"SQL Server - any equivalent of Excel's CHOOSE function?\",\n \"How to free c++ memory vector<int> * arr?\"]\n answers = [\"sql server equivalent excels choose function\", \n \"free c++ memory vectorint arr\"]\n for ex, ans in zip(examples, answers):\n if text_prepare(ex) != ans:\n return \"Wrong answer for the case: '%s'\" % ex\n return 'Basic tests are passed.'", "_____no_output_____" ], [ "print(test_text_prepare())", "Basic tests are passed.\n" ] ], [ [ "Run your implementation for questions from file *text_prepare_tests.tsv* to earn the points.", "_____no_output_____" ] ], [ [ "prepared_questions = []\nfor line in open('data/text_prepare_tests.tsv', encoding='utf-8'):\n line = text_prepare(line.strip())\n prepared_questions.append(line)\ntext_prepare_results = '\\n'.join(prepared_questions)\n\ngrader.submit_tag('TextPrepare', text_prepare_results)", "Current answer for task TextPrepare is:\n sqlite php readonly\ncreating multiple textboxes dynamically\nself one prefer javascript\nsave php date...\n" ] ], [ [ "Now we can preprocess the titles using function *text_prepare* and making sure that the headers don't have bad symbols:", "_____no_output_____" ] ], [ [ "X_train = [text_prepare(x) for x in X_train]\nX_val = [text_prepare(x) for x in X_val]\nX_test = [text_prepare(x) for x in X_test]", "_____no_output_____" ], [ "X_train[:3]", "_____no_output_____" ] ], [ [ "For each tag and for each word calculate how many times they occur in the train corpus. \n\n**Task 2 (WordsTagsCount).** Find 3 most popular tags and 3 most popular words in the train data and submit the results to earn the points.", "_____no_output_____" ] ], [ [ "from collections import Counter\n# Dictionary of all tags from train corpus with their counts.\ntags_counts = Counter() #{}\n# Dictionary of all words from train corpus with their counts.\nwords_counts = Counter() #{}\n\n######################################\n######### YOUR CODE HERE #############\n######################################\n# print(X_train[:3], y_train[:3])\nfor sentence in X_train:\n for word in sentence.split():\n # print(word)\n words_counts[word] += 1\n\nfor l in y_train:\n for tag in l:\n tags_counts[tag] += 1", "_____no_output_____" ] ], [ [ "We are assuming that *tags_counts* and *words_counts* are dictionaries like `{'some_word_or_tag': frequency}`. After applying the sorting procedure, results will be look like this: `[('most_popular_word_or_tag', frequency), ('less_popular_word_or_tag', frequency), ...]`. The grader gets the results in the following format (two comma-separated strings with line break):\n\n tag1,tag2,tag3\n word1,word2,word3\n\nPay attention that in this assignment you should not submit frequencies or some additional information.", "_____no_output_____" ] ], [ [ "most_common_tags = sorted(tags_counts.items(), key=lambda x: x[1], reverse=True)[:3]\nmost_common_words = sorted(words_counts.items(), key=lambda x: x[1], reverse=True)[:3]\n\ngrader.submit_tag('WordsTagsCount', '%s\\n%s' % (','.join(tag for tag, _ in most_common_tags), \n ','.join(word for word, _ in most_common_words)))", "Current answer for task WordsTagsCount is:\n javascript,c#,java\nusing,php,java...\n" ] ], [ [ "### Transforming text to a vector\n\nMachine Learning algorithms work with numeric data and we cannot use the provided text data \"as is\". There are many ways to transform text data to numeric vectors. In this task you will try to use two of them.\n\n#### Bag of words\n\nOne of the well-known approaches is a *bag-of-words* representation. To create this transformation, follow the steps:\n1. Find *N* most popular words in train corpus and numerate them. Now we have a dictionary of the most popular words.\n2. For each title in the corpora create a zero vector with the dimension equals to *N*.\n3. For each text in the corpora iterate over words which are in the dictionary and increase by 1 the corresponding coordinate.\n\nLet's try to do it for a toy example. Imagine that we have *N* = 4 and the list of the most popular words is \n\n ['hi', 'you', 'me', 'are']\n\nThen we need to numerate them, for example, like this: \n\n {'hi': 0, 'you': 1, 'me': 2, 'are': 3}\n\nAnd we have the text, which we want to transform to the vector:\n\n 'hi how are you'\n\nFor this text we create a corresponding zero vector \n\n [0, 0, 0, 0]\n \nAnd iterate over all words, and if the word is in the dictionary, we increase the value of the corresponding position in the vector:\n\n 'hi': [1, 0, 0, 0]\n 'how': [1, 0, 0, 0] # word 'how' is not in our dictionary\n 'are': [1, 0, 0, 1]\n 'you': [1, 1, 0, 1]\n\nThe resulting vector will be \n\n [1, 1, 0, 1]\n \nImplement the described encoding in the function *my_bag_of_words* with the size of the dictionary equals to 5000. To find the most common words use train data. You can test your code using the function *test_my_bag_of_words*.", "_____no_output_____" ] ], [ [ "most_common_words = sorted(words_counts.items(), key=lambda x: x[1], reverse=True)[:5002]", "_____no_output_____" ], [ "WORDS_TO_INDEX = {p[0]:i for i,p in enumerate(most_common_words[:5])}", "_____no_output_____" ], [ "print(WORDS_TO_INDEX)", "{'using': 0, 'php': 1, 'java': 2, 'file': 3, 'javascript': 4}\n" ], [ "DICT_SIZE = 5000\nWORDS_TO_INDEX = {p[0]:i for i,p in enumerate(most_common_words[:DICT_SIZE])}\nINDEX_TO_WORDS = {WORDS_TO_INDEX[k]:k for k in WORDS_TO_INDEX}\nALL_WORDS = WORDS_TO_INDEX.keys()\n\ndef my_bag_of_words(text, words_to_index, dict_size):\n \"\"\"\n text: a string\n dict_size: size of the dictionary\n \n return a vector which is a bag-of-words representation of 'text'\n \"\"\"\n result_vector = np.zeros(dict_size)\n ######################################\n ######### YOUR CODE HERE #############\n ######################################\n for word in text.split():\n if word in words_to_index :\n result_vector[words_to_index[word]] +=1\n return result_vector", "_____no_output_____" ], [ "def test_my_bag_of_words():\n words_to_index = {'hi': 0, 'you': 1, 'me': 2, 'are': 3}\n examples = ['hi how are you']\n answers = [[1, 1, 0, 1]]\n for ex, ans in zip(examples, answers):\n if (my_bag_of_words(ex, words_to_index, 4) != ans).any():\n return \"Wrong answer for the case: '%s'\" % ex\n return 'Basic tests are passed.'", "_____no_output_____" ], [ "print(test_my_bag_of_words())", "Basic tests are passed.\n" ] ], [ [ "Now apply the implemented function to all samples (this might take up to a minute):", "_____no_output_____" ] ], [ [ "from scipy import sparse as sp_sparse", "_____no_output_____" ], [ "X_train_mybag = sp_sparse.vstack([sp_sparse.csr_matrix(my_bag_of_words(text, WORDS_TO_INDEX, DICT_SIZE)) for text in X_train])\nX_val_mybag = sp_sparse.vstack([sp_sparse.csr_matrix(my_bag_of_words(text, WORDS_TO_INDEX, DICT_SIZE)) for text in X_val])\nX_test_mybag = sp_sparse.vstack([sp_sparse.csr_matrix(my_bag_of_words(text, WORDS_TO_INDEX, DICT_SIZE)) for text in X_test])\nprint('X_train shape ', X_train_mybag.shape)\nprint('X_val shape ', X_val_mybag.shape)\nprint('X_test shape ', X_test_mybag.shape)", "X_train shape (100000, 5000)\nX_val shape (30000, 5000)\nX_test shape (20000, 5000)\n" ] ], [ [ "As you might notice, we transform the data to sparse representation, to store the useful information efficiently. There are many [types](https://docs.scipy.org/doc/scipy/reference/sparse.html) of such representations, however sklearn algorithms can work only with [csr](https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csr_matrix.html#scipy.sparse.csr_matrix) matrix, so we will use this one.", "_____no_output_____" ], [ "**Task 3 (BagOfWords).** For the 11th row in *X_train_mybag* find how many non-zero elements it has. In this task the answer (variable *non_zero_elements_count*) should be a number, e.g. 20.", "_____no_output_____" ] ], [ [ "row = X_train_mybag[10].toarray()[0]\nnon_zero_elements_count = np.count_nonzero(row)\n\ngrader.submit_tag('BagOfWords', str(non_zero_elements_count))", "Current answer for task BagOfWords is:\n 7...\n" ], [ "len(row)", "_____no_output_____" ] ], [ [ "#### TF-IDF\n\nThe second approach extends the bag-of-words framework by taking into account total frequencies of words in the corpora. It helps to penalize too frequent words and provide better features space. \n\nImplement function *tfidf_features* using class [TfidfVectorizer](http://scikit-learn.org/stable/modules/generated/sklearn.feature_extraction.text.TfidfVectorizer.html) from *scikit-learn*. Use *train* corpus to train a vectorizer. Don't forget to take a look into the arguments that you can pass to it. We suggest that you filter out too rare words (occur less than in 5 titles) and too frequent words (occur more than in 90% of the titles). Also, use bigrams along with unigrams in your vocabulary. ", "_____no_output_____" ] ], [ [ "from sklearn.feature_extraction.text import TfidfVectorizer", "_____no_output_____" ], [ "def tfidf_features(X_train, X_val, X_test):\n \"\"\"\n X_train, X_val, X_test — samples \n return TF-IDF vectorized representation of each sample and vocabulary\n \"\"\"\n # Create TF-IDF vectorizer with a proper parameters choice\n # Fit the vectorizer on the train set\n # Transform the train, test, and val sets and return the result\n \n \n tfidf_vectorizer = TfidfVectorizer(token_pattern='(\\S+)', min_df=5, max_df=0.9, ngram_range=(1,2))\n \n ######################################\n ######### YOUR CODE HERE #############\n ######################################\n \n tfidf_vectorizer.fit(X_train)\n X_train = tfidf_vectorizer.transform(X_train)\n X_val = tfidf_vectorizer.transform(X_val)\n X_test = tfidf_vectorizer.transform(X_test)\n \n return X_train, X_val, X_test, tfidf_vectorizer.vocabulary_", "_____no_output_____" ] ], [ [ "Once you have done text preprocessing, always have a look at the results. Be very careful at this step, because the performance of future models will drastically depend on it. \n\nIn this case, check whether you have c++ or c# in your vocabulary, as they are obviously important tokens in our tags prediction task:", "_____no_output_____" ] ], [ [ "X_train_tfidf, X_val_tfidf, X_test_tfidf, tfidf_vocab = tfidf_features(X_train, X_val, X_test)\ntfidf_reversed_vocab = {i:word for word,i in tfidf_vocab.items()}", "_____no_output_____" ], [ "print('c++' in tfidf_vocab)\nprint('c#' in tfidf_vocab)", "True\nTrue\n" ] ], [ [ "If you can't find it, we need to understand how did it happen that we lost them? It happened during the built-in tokenization of TfidfVectorizer. Luckily, we can influence on this process. Get back to the function above and use '(\\S+)' regexp as a *token_pattern* in the constructor of the vectorizer. ", "_____no_output_____" ], [ "Now, use this transormation for the data and check again.", "_____no_output_____" ] ], [ [ "######### YOUR CODE HERE #############\nprint('c++' in tfidf_vocab)\nprint('c#' in tfidf_vocab)", "True\nTrue\n" ] ], [ [ "### MultiLabel classifier\n\nAs we have noticed before, in this task each example can have multiple tags. To deal with such kind of prediction, we need to transform labels in a binary form and the prediction will be a mask of 0s and 1s. For this purpose it is convenient to use [MultiLabelBinarizer](http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MultiLabelBinarizer.html) from *sklearn*.", "_____no_output_____" ] ], [ [ "from sklearn.preprocessing import MultiLabelBinarizer", "_____no_output_____" ], [ "mlb = MultiLabelBinarizer(classes=sorted(tags_counts.keys()))\ny_train = mlb.fit_transform(y_train)\ny_val = mlb.fit_transform(y_val)", "_____no_output_____" ], [ "y_train[0]", "_____no_output_____" ] ], [ [ "Implement the function *train_classifier* for training a classifier. In this task we suggest to use One-vs-Rest approach, which is implemented in [OneVsRestClassifier](http://scikit-learn.org/stable/modules/generated/sklearn.multiclass.OneVsRestClassifier.html) class. In this approach *k* classifiers (= number of tags) are trained. As a basic classifier, use [LogisticRegression](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html). It is one of the simplest methods, but often it performs good enough in text classification tasks. It might take some time, because a number of classifiers to train is large.", "_____no_output_____" ] ], [ [ "from sklearn.multiclass import OneVsRestClassifier\nfrom sklearn.linear_model import LogisticRegression, RidgeClassifier", "_____no_output_____" ], [ "def train_classifier(X_train, y_train, C = 1.0, penalty = 'l2'):\n \"\"\"\n X_train, y_train — training data\n \n return: trained classifier\n \"\"\"\n \n # Create and fit LogisticRegression wraped into OneVsRestClassifier.\n\n ######################################\n ######### YOUR CODE HERE #############\n ######################################\n lr = LogisticRegression(C=C, penalty=penalty)\n oneVsRest = OneVsRestClassifier(lr)\n oneVsRest.fit(X_train, y_train)\n \n return oneVsRest\n ", "_____no_output_____" ] ], [ [ "Train the classifiers for different data transformations: *bag-of-words* and *tf-idf*.", "_____no_output_____" ] ], [ [ "classifier_mybag = train_classifier(X_train_mybag, y_train)\nclassifier_tfidf = train_classifier(X_train_tfidf, y_train)", "_____no_output_____" ] ], [ [ "Now you can create predictions for the data. You will need two types of predictions: labels and scores.", "_____no_output_____" ] ], [ [ "y_val_predicted_labels_mybag = classifier_mybag.predict(X_val_mybag)\ny_val_predicted_scores_mybag = classifier_mybag.decision_function(X_val_mybag)\n\ny_val_predicted_labels_tfidf = classifier_tfidf.predict(X_val_tfidf)\ny_val_predicted_scores_tfidf = classifier_tfidf.decision_function(X_val_tfidf)", "_____no_output_____" ] ], [ [ "Now take a look at how classifier, which uses TF-IDF, works for a few examples:", "_____no_output_____" ] ], [ [ "y_val_pred_inversed = mlb.inverse_transform(y_val_predicted_labels_tfidf)\ny_val_inversed = mlb.inverse_transform(y_val)\nfor i in range(3):\n print('Title:\\t{}\\nTrue labels:\\t{}\\nPredicted labels:\\t{}\\n\\n'.format(\n X_val[i],\n ','.join(y_val_inversed[i]),\n ','.join(y_val_pred_inversed[i])\n ))", "Title:\todbc_exec always fail\nTrue labels:\tphp,sql\nPredicted labels:\t\n\n\nTitle:\taccess base classes variable within child class\nTrue labels:\tjavascript\nPredicted labels:\t\n\n\nTitle:\tcontenttype application json required rails\nTrue labels:\truby,ruby-on-rails\nPredicted labels:\tjson,ruby-on-rails\n\n\n" ] ], [ [ "Now, we would need to compare the results of different predictions, e.g. to see whether TF-IDF transformation helps or to try different regularization techniques in logistic regression. For all these experiments, we need to setup evaluation procedure. ", "_____no_output_____" ], [ "### Evaluation\n\nTo evaluate the results we will use several classification metrics:\n - [Accuracy](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.accuracy_score.html)\n - [F1-score](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.f1_score.html)\n - [Area under ROC-curve](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_auc_score.html)\n - [Area under precision-recall curve](http://scikit-learn.org/stable/modules/generated/sklearn.metrics.average_precision_score.html#sklearn.metrics.average_precision_score) \n \nMake sure you are familiar with all of them. How would you expect the things work for the multi-label scenario? Read about micro/macro/weighted averaging following the sklearn links provided above.", "_____no_output_____" ] ], [ [ "from sklearn.metrics import accuracy_score\nfrom sklearn.metrics import f1_score\nfrom sklearn.metrics import roc_auc_score \nfrom sklearn.metrics import average_precision_score\nfrom sklearn.metrics import recall_score", "_____no_output_____" ] ], [ [ "Implement the function *print_evaluation_scores* which calculates and prints to stdout:\n - *accuracy*\n - *F1-score macro/micro/weighted*\n - *Precision macro/micro/weighted*", "_____no_output_____" ] ], [ [ "def print_evaluation_scores(y_val, predicted):\n \n ######################################\n ######### YOUR CODE HERE #############\n ######################################\n #print('accuracy')\n print(f1_score(y_val, predicted, average = 'weighted'))\n \"\"\"\n #print('f1_score_macro')\n print(f1_score(y_val,predicted, average = 'macro')\n #print('f1_score_micro')\n print(f1_score(y_val,predicted, average = 'micro')\n #print('f1_score_weighted')\n print(f1_score(y_val,predicted, average = 'weighted')\n \"\"\"", "_____no_output_____" ], [ "print('Bag-of-words')\nprint_evaluation_scores(y_val, y_val_predicted_labels_mybag)\nprint('Tfidf')\nprint_evaluation_scores(y_val, y_val_predicted_labels_tfidf)", "Bag-of-words\n0.6486956090682869\nTfidf\n0.6143558163126149\n" ] ], [ [ "You might also want to plot some generalization of the [ROC curve](http://scikit-learn.org/stable/modules/model_evaluation.html#receiver-operating-characteristic-roc) for the case of multi-label classification. Provided function *roc_auc* can make it for you. The input parameters of this function are:\n - true labels\n - decision functions scores\n - number of classes", "_____no_output_____" ] ], [ [ "from metrics import roc_auc\n%matplotlib inline", "_____no_output_____" ], [ "n_classes = len(tags_counts)\nroc_auc(y_val, y_val_predicted_scores_mybag, n_classes)", "_____no_output_____" ], [ "n_classes = len(tags_counts)\nroc_auc(y_val, y_val_predicted_scores_tfidf, n_classes)", "_____no_output_____" ] ], [ [ "**Task 4 (MultilabelClassification).** Once we have the evaluation set up, we suggest that you experiment a bit with training your classifiers. We will use *F1-score weighted* as an evaluation metric. Our recommendation:\n- compare the quality of the bag-of-words and TF-IDF approaches and chose one of them.\n- for the chosen one, try *L1* and *L2*-regularization techniques in Logistic Regression with different coefficients (e.g. C equal to 0.1, 1, 10, 100).\n\nYou also could try other improvements of the preprocessing / model, if you want. ", "_____no_output_____" ] ], [ [ " def EvaluateDifferentModel(C, penalty) :\n classifier_mybag = train_classifier(X_train_mybag, y_train, C, penalty)\n classifier_tfidf = train_classifier(X_train_tfidf, y_train, C, penalty)\n y_val_predicted_labels_mybag = classifier_mybag.predict(X_val_mybag)\n y_val_predicted_scores_mybag = classifier_mybag.decision_function(X_val_mybag)\n y_val_predicted_labels_tfidf = classifier_tfidf.predict(X_val_tfidf)\n y_val_predicted_scores_tfidf = classifier_tfidf.decision_function(X_val_tfidf)\n \n print('Bag-of-words')\n print_evaluation_scores(y_val, y_val_predicted_labels_mybag)\n print('Tfidf')\n print_evaluation_scores(y_val, y_val_predicted_labels_tfidf)", "_____no_output_____" ], [ "EvaluateDifferentModel(0.1,'l1')\nEvaluateDifferentModel(0.1,'l2')\nEvaluateDifferentModel(1,'l1')\nEvaluateDifferentModel(1,'l2')\nEvaluateDifferentModel(10,'l1')\nEvaluateDifferentModel(10,'l2')\nEvaluateDifferentModel(100,'l1')\nEvaluateDifferentModel(100,'l2')", "Bag-of-words\n0.6116000654698222\nTfidf\n" ], [ "######################################\n######### YOUR CODE HERE #############\n######################################\nclassifier_tfidf = train_classifier(X_train_tfidf, y_train, C=1.0, penalty='l1')\ny_test_predicted_labels_tfidf = classifier_tfidf.predict(X_test_tfidf)", "_____no_output_____" ] ], [ [ "When you are happy with the quality, create predictions for *test* set, which you will submit to Coursera.", "_____no_output_____" ] ], [ [ "test_predictions = y_test_predicted_labels_tfidf ######### YOUR CODE HERE #############\ntest_pred_inversed = mlb.inverse_transform(test_predictions)\n\ntest_predictions_for_submission = '\\n'.join('%i\\t%s' % (i, ','.join(row)) for i, row in enumerate(test_pred_inversed))\ngrader.submit_tag('MultilabelClassification', test_predictions_for_submission)", "Current answer for task MultilabelClassification is:\n 0\tmysql,php\n1\tjavascript\n2\t\n3\tjavascript,jquery\n4\tandroid,java\n5\tphp,xml\n6\tjson\n7\tjava,swing\n8\tpytho...\n" ] ], [ [ "### Analysis of the most important features", "_____no_output_____" ], [ "Finally, it is usually a good idea to look at the features (words or n-grams) that are used with the largest weigths in your logistic regression model.", "_____no_output_____" ], [ "Implement the function *print_words_for_tag* to find them. Get back to sklearn documentation on [OneVsRestClassifier](http://scikit-learn.org/stable/modules/generated/sklearn.multiclass.OneVsRestClassifier.html) and [LogisticRegression](http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html) if needed.", "_____no_output_____" ] ], [ [ "def print_words_for_tag(classifier, tag, tags_classes, index_to_words, all_words):\n \"\"\"\n classifier: trained classifier\n tag: particular tag\n tags_classes: a list of classes names from MultiLabelBinarizer\n index_to_words: index_to_words transformation\n all_words: all words in the dictionary\n \n return nothing, just print top 5 positive and top 5 negative words for current tag\n \"\"\"\n print('Tag:\\t{}'.format(tag))\n \n # Extract an estimator from the classifier for the given tag.\n # Extract feature coefficients from the estimator. \n \n ######################################\n ######### YOUR CODE HERE #############\n ######################################\n idx = tags_classes.index(tag)\n coef=classifier_tfidf.coef_[idx]\n cd = {i:coef[i] for i in range(len(coef))}\n scd=sorted(cd.items(), key=lambda x: x[1], reverse=True)\n \n top_positive_words = [index_to_words[k[0]] for k in scd[:5]] # top-5 words sorted by the coefficiens.\n top_negative_words = [index_to_words[k[0]] for k in scd[-5:]] # bottom-5 words sorted by the coefficients.\n print('Top positive words:\\t{}'.format(', '.join(top_positive_words)))\n print('Top negative words:\\t{}\\n'.format(', '.join(top_negative_words)))", "_____no_output_____" ], [ "print_words_for_tag(classifier_tfidf, 'c', mlb.classes, tfidf_reversed_vocab, ALL_WORDS)\nprint_words_for_tag(classifier_tfidf, 'c++', mlb.classes, tfidf_reversed_vocab, ALL_WORDS)\nprint_words_for_tag(classifier_tfidf, 'linux', mlb.classes, tfidf_reversed_vocab, ALL_WORDS)", "Tag:\tc\nTop positive words:\tc, malloc, scanf, printf, gcc\nTop negative words:\tc#, javascript, python, php, java\n\nTag:\tc++\nTop positive words:\tc++, qt, boost, mfc, opencv\nTop negative words:\tc#, javascript, python, php, java\n\nTag:\tlinux\nTop positive words:\tlinux, ubuntu, c, address, signal\nTop negative words:\tmethod, array, jquery, c#, javascript\n\n" ] ], [ [ "### Authorization & Submission\nTo submit assignment parts to Cousera platform, please, enter your e-mail and token into variables below. You can generate token on this programming assignment page. <b>Note:</b> Token expires 30 minutes after generation.", "_____no_output_____" ] ], [ [ "grader.status()", "You want to submit these parts:\nTask TextPrepare:\n sqlite php readonly\ncreating multiple textboxes dynamically\nself one prefer javascript\nsave php date...\nTask WordsTagsCount:\n javascript,c#,java\nusing,php,java...\nTask BagOfWords:\n 7...\nTask MultilabelClassification:\n 0\tphp\n1\tjavascript,jquery\n2\t\n3\tjavascript,jquery\n4\tandroid,java\n5\tphp,xml\n6\tjson\n7\tjava\n8\tpython\n9\th...\n" ], [ "STUDENT_EMAIL = \"[email protected]\"# EMAIL \nSTUDENT_TOKEN = \"X6mGG4lxlszGyk9H\"# TOKEN \ngrader.status()", "You want to submit these parts:\nTask TextPrepare:\n sqlite php readonly\ncreating multiple textboxes dynamically\nself one prefer javascript\nsave php date...\nTask WordsTagsCount:\n javascript,c#,java\nusing,php,java...\nTask BagOfWords:\n 7...\nTask MultilabelClassification:\n 0\tmysql,php\n1\tjavascript\n2\t\n3\tjavascript,jquery\n4\tandroid,java\n5\tphp,xml\n6\tjson\n7\tjava,swing\n8\tpytho...\n" ] ], [ [ "If you want to submit these answers, run cell below", "_____no_output_____" ] ], [ [ "grader.submit(STUDENT_EMAIL, STUDENT_TOKEN)", "Submitted to Coursera platform. See results on assignment page!\n" ], [ "", "_____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", "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", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown", "markdown", "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ] ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Medical Image Classification Tutorial with the MedNIST Dataset", "_____no_output_____" ], [ "## Introduction\n\nIn this tutorial, we introduce an end-to-end training and evaluation example based on the MedNIST dataset. \nWe'll go through the following steps:\n<ul>\n <li>Create a dataset for training and testing</li>\n <li>Use MONAI transforms to pre-process data</li>\n <li>Use the DenseNet from MONAI for classification</li>\n <li>Train the model with a PyTorch program</li>\n <li>Evaluate on test dataset</li>\n</ul>\n", "_____no_output_____" ], [ "### Get the dataset\n\nThe MedNIST dataset was gathered from several sets from [TCIA](https://wiki.cancerimagingarchive.net/display/Public/Data+Usage+Policies+and+Restrictions), [the RSNA Bone Age Challenge](http://rsnachallenges.cloudapp.net/competitions/4), and [the NIH Chest X-ray dataset](https://cloud.google.com/healthcare/docs/resources/public-datasets/nih-chest).\n\nThe dataset is kindly made available by [Dr. Bradley J. Erickson M.D., Ph.D.](https://www.mayo.edu/research/labs/radiology-informatics/overview) (Department of Radiology, Mayo Clinic)\nunder the Creative Commons [CC BY-SA 4.0 license](https://creativecommons.org/licenses/by-sa/4.0/).\nIf you use the MedNIST dataset, please acknowledge the source, e.g.\n\nhttps://github.com/Project-MONAI/MONAI/blob/master/examples/notebooks/mednist_tutorial.ipynb.\n\nThe following commands download and unzip the dataset (~60MB).", "_____no_output_____" ] ], [ [ "!wget https://www.dropbox.com/s/5wwskxctvcxiuea/MedNIST.tar.gz", "--2020-07-08 08:50:05-- https://www.dropbox.com/s/5wwskxctvcxiuea/MedNIST.tar.gz\nResolving www.dropbox.com (www.dropbox.com)... 162.125.82.1, 2620:100:6032:1::a27d:5201\nConnecting to www.dropbox.com (www.dropbox.com)|162.125.82.1|:443... connected.\nHTTP request sent, awaiting response... 301 Moved Permanently\nLocation: /s/raw/5wwskxctvcxiuea/MedNIST.tar.gz [following]\n--2020-07-08 08:50:06-- https://www.dropbox.com/s/raw/5wwskxctvcxiuea/MedNIST.tar.gz\nReusing existing connection to www.dropbox.com:443.\nHTTP request sent, awaiting response... 302 Found\nLocation: https://ucf87fb94e4db4ff0b5ccc540922.dl.dropboxusercontent.com/cd/0/inline/A7HBOQSNhIryWngUdvVYJp10xl3-oBB6NC8AZiARn_xABLNWkN207TajHxk58Ip4H655VkH7ZyFPZ5RQLXhZeiYcTaFdedviIQwHthxlcyXlmETFkjkq33izoJNsfzMyxB4/file# [following]\n--2020-07-08 08:50:06-- https://ucf87fb94e4db4ff0b5ccc540922.dl.dropboxusercontent.com/cd/0/inline/A7HBOQSNhIryWngUdvVYJp10xl3-oBB6NC8AZiARn_xABLNWkN207TajHxk58Ip4H655VkH7ZyFPZ5RQLXhZeiYcTaFdedviIQwHthxlcyXlmETFkjkq33izoJNsfzMyxB4/file\nResolving ucf87fb94e4db4ff0b5ccc540922.dl.dropboxusercontent.com (ucf87fb94e4db4ff0b5ccc540922.dl.dropboxusercontent.com)... 162.125.82.15, 2620:100:6032:15::a27d:520f\nConnecting to ucf87fb94e4db4ff0b5ccc540922.dl.dropboxusercontent.com (ucf87fb94e4db4ff0b5ccc540922.dl.dropboxusercontent.com)|162.125.82.15|:443... connected.\nHTTP request sent, awaiting response... 302 Found\nLocation: /cd/0/inline2/A7GO7eRd3Z36tEsWL5q7uBPWWfH4XYskKV4J_cUOOvk20qhCJ7r5qqenLTjIbErbw_MKZsiYke9prAjXuzAkPf7VG0m_9cGwg9EuuicoXnVNM2-NRM-0S1Ht3CKp78eHKoFf1Pg279AwLF5U8IXQHWLIy9RxytnrvpNKYUdmU6z7wTV1msC3Gf5cMl_gDOOLfNlJWGKAYBOr-FppXC5OJ7vSdgAA4V7YHWXF_JkAA2xec5z5QbnFp6P5VVVKy0CybXlr6Wxhbuq9mNsSef-6_kXC40IRktZt2qOolxNzKqhTSPHNVGnvofwedtub8U8tFPLYikn4FbojtVSOmImlDzEtMgBVsBTnZT8lpnRY-e7yVA/file [following]\n--2020-07-08 08:50:07-- https://ucf87fb94e4db4ff0b5ccc540922.dl.dropboxusercontent.com/cd/0/inline2/A7GO7eRd3Z36tEsWL5q7uBPWWfH4XYskKV4J_cUOOvk20qhCJ7r5qqenLTjIbErbw_MKZsiYke9prAjXuzAkPf7VG0m_9cGwg9EuuicoXnVNM2-NRM-0S1Ht3CKp78eHKoFf1Pg279AwLF5U8IXQHWLIy9RxytnrvpNKYUdmU6z7wTV1msC3Gf5cMl_gDOOLfNlJWGKAYBOr-FppXC5OJ7vSdgAA4V7YHWXF_JkAA2xec5z5QbnFp6P5VVVKy0CybXlr6Wxhbuq9mNsSef-6_kXC40IRktZt2qOolxNzKqhTSPHNVGnvofwedtub8U8tFPLYikn4FbojtVSOmImlDzEtMgBVsBTnZT8lpnRY-e7yVA/file\nReusing existing connection to ucf87fb94e4db4ff0b5ccc540922.dl.dropboxusercontent.com:443.\nHTTP request sent, awaiting response... 200 OK\nLength: 61834679 (59M) [application/octet-stream]\nSaving to: ‘MedNIST.tar.gz’\n\nMedNIST.tar.gz 100%[===================>] 58.97M 12.4MB/s in 4.8s \n\n2020-07-08 08:50:13 (12.4 MB/s) - ‘MedNIST.tar.gz’ saved [61834679/61834679]\n\n" ], [ "# unzip the '.tar.gz' file to the current directory\nimport tarfile\ndatafile = tarfile.open('MedNIST.tar.gz')\ndatafile.extractall()\ndatafile.close()", "_____no_output_____" ], [ "import os\nimport numpy as np\n%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom PIL import Image\n\nimport torch\nimport torch.nn.functional as F\nfrom torch.utils.data import Dataset, DataLoader\n\nfrom monai.transforms import \\\n Compose, LoadPNG, AddChannel, ScaleIntensity, ToTensor, RandRotate, RandFlip, RandZoom\nfrom monai.networks.nets import densenet121\nfrom monai.metrics import compute_roc_auc\n\nnp.random.seed(0)", "_____no_output_____" ] ], [ [ "## Read image filenames from the dataset folders\nFirst of all, check the dataset files and show some statistics. \nThere are 6 folders in the dataset: Hand, AbdomenCT, CXR, ChestCT, BreastMRI, HeadCT, \nwhich should be used as the labels to train our classification model.", "_____no_output_____" ] ], [ [ "data_dir = './MedNIST/'\nclass_names = sorted([x for x in os.listdir(data_dir) if os.path.isdir(os.path.join(data_dir, x))])\nnum_class = len(class_names)\nimage_files = [[os.path.join(data_dir, class_names[i], x)\n for x in os.listdir(os.path.join(data_dir, class_names[i]))]\n for i in range(num_class)]\nnum_each = [len(image_files[i]) for i in range(num_class)]\nimage_files_list = []\nimage_class = []\nfor i in range(num_class):\n image_files_list.extend(image_files[i])\n image_class.extend([i] * num_each[i])\nnum_total = len(image_class)\nimage_width, image_height = Image.open(image_files_list[0]).size\n\nprint(f\"Total image count: {num_total}\")\nprint(f\"Image dimensions: {image_width} x {image_height}\")\nprint(f\"Label names: {class_names}\")\nprint(f\"Label counts: {num_each}\")", "Total image count: 58954\nImage dimensions: 64 x 64\nLabel names: ['AbdomenCT', 'BreastMRI', 'CXR', 'ChestCT', 'Hand', 'HeadCT']\nLabel counts: [10000, 8954, 10000, 10000, 10000, 10000]\n" ] ], [ [ "## Randomly pick images from the dataset to visualize and check", "_____no_output_____" ] ], [ [ "plt.subplots(3, 3, figsize=(8, 8))\nfor i,k in enumerate(np.random.randint(num_total, size=9)):\n im = Image.open(image_files_list[k])\n arr = np.array(im)\n plt.subplot(3, 3, i + 1)\n plt.xlabel(class_names[image_class[k]])\n plt.imshow(arr, cmap='gray', vmin=0, vmax=255)\nplt.tight_layout()\nplt.show()", "_____no_output_____" ] ], [ [ "## Prepare training, validation and test data lists\nRandomly select 10% of the dataset as validation and 10% as test.", "_____no_output_____" ] ], [ [ "val_frac = 0.1\ntest_frac = 0.1\ntrain_x = list()\ntrain_y = list()\nval_x = list()\nval_y = list()\ntest_x = list()\ntest_y = list()\n\nfor i in range(num_total):\n rann = np.random.random()\n if rann < val_frac:\n val_x.append(image_files_list[i])\n val_y.append(image_class[i])\n elif rann < test_frac + val_frac:\n test_x.append(image_files_list[i])\n test_y.append(image_class[i])\n else:\n train_x.append(image_files_list[i])\n train_y.append(image_class[i])\n\nprint(f\"Training count: {len(train_x)}, Validation count: {len(val_x)}, Test count: {len(test_x)}\")", "Training count: 47156, Validation count: 5913, Test count: 5885\n" ] ], [ [ "## Define MONAI transforms, Dataset and Dataloader to pre-process data", "_____no_output_____" ] ], [ [ "train_transforms = Compose([\n LoadPNG(image_only=True),\n AddChannel(),\n ScaleIntensity(),\n RandRotate(range_x=15, prob=0.5, keep_size=True),\n RandFlip(spatial_axis=0, prob=0.5),\n RandZoom(min_zoom=0.9, max_zoom=1.1, prob=0.5),\n ToTensor()\n])\n\nval_transforms = Compose([\n LoadPNG(image_only=True),\n AddChannel(),\n ScaleIntensity(),\n ToTensor()\n])", "_____no_output_____" ], [ "class MedNISTDataset(Dataset):\n\n def __init__(self, image_files, labels, transforms):\n self.image_files = image_files\n self.labels = labels\n self.transforms = transforms\n\n def __len__(self):\n return len(self.image_files)\n\n def __getitem__(self, index):\n return self.transforms(self.image_files[index]), self.labels[index]\n\ntrain_ds = MedNISTDataset(train_x, train_y, train_transforms)\ntrain_loader = DataLoader(train_ds, batch_size=300, shuffle=True, num_workers=10)\n\nval_ds = MedNISTDataset(val_x, val_y, val_transforms)\nval_loader = DataLoader(val_ds, batch_size=300, num_workers=10)\n\ntest_ds = MedNISTDataset(test_x, test_y, val_transforms)\ntest_loader = DataLoader(test_ds, batch_size=300, num_workers=10)", "_____no_output_____" ] ], [ [ "## Define network and optimizer\n1. Set learning rate for how much the model is updated per batch.\n2. Set total epoch number, as we have shuffle and random transforms, so the training data of every epoch is different. \n And as this is just a get start tutorial, let's just train 4 epochs. \n If train 10 epochs, the model can achieve 100% accuracy on test dataset.\n3. Use DenseNet from MONAI and move to GPU devide, this DenseNet can support both 2D and 3D classification tasks.\n4. Use Adam optimizer.", "_____no_output_____" ] ], [ [ "device = torch.device('cuda:0')\nmodel = densenet121(\n spatial_dims=2,\n in_channels=1,\n out_channels=num_class\n).to(device)\nloss_function = torch.nn.CrossEntropyLoss()\noptimizer = torch.optim.Adam(model.parameters(), 1e-5)\nepoch_num = 4\nval_interval = 1", "_____no_output_____" ] ], [ [ "## Model training\nExecute a typical PyTorch training that run epoch loop and step loop, and do validation after every epoch. \nWill save the model weights to file if got best validation accuracy.", "_____no_output_____" ] ], [ [ "best_metric = -1\nbest_metric_epoch = -1\nepoch_loss_values = list()\nmetric_values = list()\nfor epoch in range(epoch_num):\n print('-' * 10)\n print(f\"epoch {epoch + 1}/{epoch_num}\")\n model.train()\n epoch_loss = 0\n step = 0\n for batch_data in train_loader:\n step += 1\n inputs, labels = batch_data[0].to(device), batch_data[1].to(device)\n optimizer.zero_grad()\n outputs = model(inputs)\n loss = loss_function(outputs, labels)\n loss.backward()\n optimizer.step()\n epoch_loss += loss.item()\n print(f\"{step}/{len(train_ds) // train_loader.batch_size}, train_loss: {loss.item():.4f}\")\n epoch_len = len(train_ds) // train_loader.batch_size\n epoch_loss /= step\n epoch_loss_values.append(epoch_loss)\n print(f\"epoch {epoch + 1} average loss: {epoch_loss:.4f}\")\n\n if (epoch + 1) % val_interval == 0:\n model.eval()\n with torch.no_grad():\n y_pred = torch.tensor([], dtype=torch.float32, device=device)\n y = torch.tensor([], dtype=torch.long, device=device)\n for val_data in val_loader:\n val_images, val_labels = val_data[0].to(device), val_data[1].to(device)\n y_pred = torch.cat([y_pred, model(val_images)], dim=0)\n y = torch.cat([y, val_labels], dim=0)\n auc_metric = compute_roc_auc(y_pred, y, to_onehot_y=True, softmax=True)\n metric_values.append(auc_metric)\n acc_value = torch.eq(y_pred.argmax(dim=1), y)\n acc_metric = acc_value.sum().item() / len(acc_value)\n if auc_metric > best_metric:\n best_metric = auc_metric\n best_metric_epoch = epoch + 1\n torch.save(model.state_dict(), 'best_metric_model.pth')\n print('saved new best metric model')\n print(f\"current epoch: {epoch + 1} current AUC: {auc_metric:.4f}\"\n f\" current accuracy: {acc_metric:.4f} best AUC: {best_metric:.4f}\"\n f\" at epoch: {best_metric_epoch}\")\nprint(f\"train completed, best_metric: {best_metric:.4f} at epoch: {best_metric_epoch}\")", "_____no_output_____" ] ], [ [ "## Plot the loss and metric", "_____no_output_____" ] ], [ [ "plt.figure('train', (12, 6))\nplt.subplot(1, 2, 1)\nplt.title('Epoch Average Loss')\nx = [i + 1 for i in range(len(epoch_loss_values))]\ny = epoch_loss_values\nplt.xlabel('epoch')\nplt.plot(x, y)\nplt.subplot(1, 2, 2)\nplt.title('Val AUC')\nx = [val_interval * (i + 1) for i in range(len(metric_values))]\ny = metric_values\nplt.xlabel('epoch')\nplt.plot(x, y)\nplt.show()", "_____no_output_____" ] ], [ [ "## Evaluate the model on test dataset\nAfter training and validation, we already got the best model on validation test. \nWe need to evaluate the model on test dataset to check whether it's robust and not over-fitting. \nWe'll use these predictions to generate a classification report.", "_____no_output_____" ] ], [ [ "model.load_state_dict(torch.load('best_metric_model.pth'))\nmodel.eval()\ny_true = list()\ny_pred = list()\nwith torch.no_grad():\n for test_data in test_loader:\n test_images, test_labels = test_data[0].to(device), test_data[1].to(device)\n pred = model(test_images).argmax(dim=1)\n for i in range(len(pred)):\n y_true.append(test_labels[i].item())\n y_pred.append(pred[i].item())", "_____no_output_____" ], [ "! pip install -U sklearn", "_____no_output_____" ], [ "from sklearn.metrics import classification_report\nprint(classification_report(y_true, y_pred, target_names=class_names, digits=4))", " precision recall f1-score support\n\n Hand 0.9969 0.9928 0.9948 969\n AbdomenCT 0.9839 0.9924 0.9881 1046\n CXR 0.9948 0.9969 0.9958 961\n ChestCT 0.9969 1.0000 0.9985 980\n BreastMRI 1.0000 0.9905 0.9952 944\n HeadCT 0.9929 0.9919 0.9924 985\n\n accuracy 0.9941 5885\n macro avg 0.9942 0.9941 0.9941 5885\nweighted avg 0.9941 0.9941 0.9941 5885\n\n" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<h1 align=\"center\">TensorFlow Neural Network Lab</h1>", "_____no_output_____" ], [ "<img src=\"image/notmnist.png\">\nIn this lab, you'll use all the tools you learned from *Introduction to TensorFlow* to label images of English letters! The data you are using, <a href=\"http://yaroslavvb.blogspot.com/2011/09/notmnist-dataset.html\">notMNIST</a>, consists of images of a letter from A to J in differents font.\n\nThe above images are a few examples of the data you'll be training on. After training the network, you will compare your prediction model against test data. Your goal, by the end of this lab, is to make predictions against that test set with at least an 80% accuracy. Let's jump in!", "_____no_output_____" ], [ "To start this lab, you first need to import all the necessary modules. Run the code below. If it runs successfully, it will print \"`All modules imported`\".", "_____no_output_____" ] ], [ [ "import hashlib\nimport os\nimport pickle\nfrom urllib.request import urlretrieve\n\nimport numpy as np\nfrom PIL import Image\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import LabelBinarizer\nfrom sklearn.utils import resample\nfrom tqdm import tqdm\nfrom zipfile import ZipFile\n\nprint('All modules imported.')", "All modules imported.\n" ] ], [ [ "The notMNIST dataset is too large for many computers to handle. It contains 500,000 images for just training. You'll be using a subset of this data, 15,000 images for each label (A-J).", "_____no_output_____" ] ], [ [ "def download(url, file):\n \"\"\"\n Download file from <url>\n :param url: URL to file\n :param file: Local file path\n \"\"\"\n if not os.path.isfile(file):\n print('Downloading ' + file + '...')\n urlretrieve(url, file)\n print('Download Finished')\n\n# Download the training and test dataset.\ndownload('https://s3.amazonaws.com/udacity-sdc/notMNIST_train.zip', 'notMNIST_train.zip')\ndownload('https://s3.amazonaws.com/udacity-sdc/notMNIST_test.zip', 'notMNIST_test.zip')\n\n# Make sure the files aren't corrupted\nassert hashlib.md5(open('notMNIST_train.zip', 'rb').read()).hexdigest() == 'c8673b3f28f489e9cdf3a3d74e2ac8fa',\\\n 'notMNIST_train.zip file is corrupted. Remove the file and try again.'\nassert hashlib.md5(open('notMNIST_test.zip', 'rb').read()).hexdigest() == '5d3c7e653e63471c88df796156a9dfa9',\\\n 'notMNIST_test.zip file is corrupted. Remove the file and try again.'\n\n# Wait until you see that all files have been downloaded.\nprint('All files downloaded.')", "All files downloaded.\n" ], [ "def uncompress_features_labels(file):\n \"\"\"\n Uncompress features and labels from a zip file\n :param file: The zip file to extract the data from\n \"\"\"\n features = []\n labels = []\n\n with ZipFile(file) as zipf:\n # Progress Bar\n filenames_pbar = tqdm(zipf.namelist(), unit='files')\n \n # Get features and labels from all files\n for filename in filenames_pbar:\n # Check if the file is a directory\n if not filename.endswith('/'):\n with zipf.open(filename) as image_file:\n image = Image.open(image_file)\n image.load()\n # Load image data as 1 dimensional array\n # We're using float32 to save on memory space\n feature = np.array(image, dtype=np.float32).flatten()\n\n # Get the the letter from the filename. This is the letter of the image.\n label = os.path.split(filename)[1][0]\n\n features.append(feature)\n labels.append(label)\n return np.array(features), np.array(labels)\n\n# Get the features and labels from the zip files\ntrain_features, train_labels = uncompress_features_labels('notMNIST_train.zip')\ntest_features, test_labels = uncompress_features_labels('notMNIST_test.zip')\n\n# Limit the amount of data to work with a docker container\ndocker_size_limit = 150000\ntrain_features, train_labels = resample(train_features, train_labels, n_samples=docker_size_limit)\n\n# Set flags for feature engineering. This will prevent you from skipping an important step.\nis_features_normal = False\nis_labels_encod = False\n\n# Wait until you see that all features and labels have been uncompressed.\nprint('All features and labels uncompressed.')", "100%|██████████| 210001/210001 [00:49<00:00, 4284.12files/s]\n100%|██████████| 10001/10001 [00:02<00:00, 4503.60files/s]\n" ] ], [ [ "<img src=\"image/mean_variance.png\" style=\"height: 75%;width: 75%; position: relative; right: 5%\">\n\n## Problem 1\nThe first problem involves normalizing the features for your training and test data.\n\nImplement Min-Max scaling in the `normalize()` function to a range of `a=0.1` and `b=0.9`. After scaling, the values of the pixels in the input data should range from 0.1 to 0.9.\n\nSince the raw notMNIST image data is in [grayscale](https://en.wikipedia.org/wiki/Grayscale), the current values range from a min of 0 to a max of 255.\n\nMin-Max Scaling:\n$\nX'=a+{\\frac {\\left(X-X_{\\min }\\right)\\left(b-a\\right)}{X_{\\max }-X_{\\min }}}\n$\n\n*If you're having trouble solving problem 1, you can view the solution [here](https://github.com/udacity/CarND-TensorFlow-Lab/blob/master/solutions.ipynb).*", "_____no_output_____" ] ], [ [ "from sklearn.preprocessing import MinMaxScaler\n\n# Problem 1 - Implement Min-Max scaling for grayscale image data\ndef normalize_grayscale(image_data):\n \"\"\"\n Normalize the image data with Min-Max scaling to a range of [0.1, 0.9]\n :param image_data: The image data to be normalized\n :return: Normalized image data\n \"\"\"\n # TODO: Implement Min-Max scaling for grayscale image data\n a = 0.1\n b = 0.9\n grayscale_min = 0\n grayscale_max = 255\n return a + ( ( (image_data - grayscale_min)*(b - a) )/( grayscale_max - grayscale_min ) )\n\n### DON'T MODIFY ANYTHING BELOW ###\n# Test Cases\nnp.testing.assert_array_almost_equal(\n normalize_grayscale(np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 255])),\n [0.1, 0.103137254902, 0.106274509804, 0.109411764706, 0.112549019608, 0.11568627451, 0.118823529412, 0.121960784314,\n 0.125098039216, 0.128235294118, 0.13137254902, 0.9],\n decimal=3)\nnp.testing.assert_array_almost_equal(\n normalize_grayscale(np.array([0, 1, 10, 20, 30, 40, 233, 244, 254,255])),\n [0.1, 0.103137254902, 0.13137254902, 0.162745098039, 0.194117647059, 0.225490196078, 0.830980392157, 0.865490196078,\n 0.896862745098, 0.9])\n\nif not is_features_normal:\n train_features = normalize_grayscale(train_features)\n test_features = normalize_grayscale(test_features)\n is_features_normal = True\n\nprint('Tests Passed!')", "Tests Passed!\n" ], [ "if not is_labels_encod:\n # Turn labels into numbers and apply One-Hot Encoding\n encoder = LabelBinarizer()\n encoder.fit(train_labels)\n train_labels = encoder.transform(train_labels)\n test_labels = encoder.transform(test_labels)\n\n # Change to float32, so it can be multiplied against the features in TensorFlow, which are float32\n train_labels = train_labels.astype(np.float32)\n test_labels = test_labels.astype(np.float32)\n is_labels_encod = True\n\nprint('Labels One-Hot Encoded')", "Labels One-Hot Encoded\n" ], [ "assert is_features_normal, 'You skipped the step to normalize the features'\nassert is_labels_encod, 'You skipped the step to One-Hot Encode the labels'\n\n# Get randomized datasets for training and validation\ntrain_features, valid_features, train_labels, valid_labels = train_test_split(\n train_features,\n train_labels,\n test_size=0.05,\n random_state=832289)\n\nprint('Training features and labels randomized and split.')", "Training features and labels randomized and split.\n" ], [ "# Save the data for easy access\npickle_file = 'notMNIST.pickle'\nif not os.path.isfile(pickle_file):\n print('Saving data to pickle file...')\n try:\n with open('notMNIST.pickle', 'wb') as pfile:\n pickle.dump(\n {\n 'train_dataset': train_features,\n 'train_labels': train_labels,\n 'valid_dataset': valid_features,\n 'valid_labels': valid_labels,\n 'test_dataset': test_features,\n 'test_labels': test_labels,\n },\n pfile, pickle.HIGHEST_PROTOCOL)\n except Exception as e:\n print('Unable to save data to', pickle_file, ':', e)\n raise\n\nprint('Data cached in pickle file.')", "Data cached in pickle file.\n" ] ], [ [ "# Checkpoint\nAll your progress is now saved to the pickle file. If you need to leave and comeback to this lab, you no longer have to start from the beginning. Just run the code block below and it will load all the data and modules required to proceed.", "_____no_output_____" ] ], [ [ "%matplotlib inline\n\n# Load the modules\nimport pickle\nimport math\n\nimport numpy as np\nimport tensorflow as tf\nfrom tqdm import tqdm\nimport matplotlib.pyplot as plt\n\n# Reload the data\npickle_file = 'notMNIST.pickle'\nwith open(pickle_file, 'rb') as f:\n pickle_data = pickle.load(f)\n train_features = pickle_data['train_dataset']\n train_labels = pickle_data['train_labels']\n valid_features = pickle_data['valid_dataset']\n valid_labels = pickle_data['valid_labels']\n test_features = pickle_data['test_dataset']\n test_labels = pickle_data['test_labels']\n del pickle_data # Free up memory\n\n\nprint('Data and modules loaded.')", "_____no_output_____" ] ], [ [ "<img src=\"image/weight_biases.png\" style=\"height: 60%;width: 60%; position: relative; right: 10%\">\n\n## Problem 2\nFor the neural network to train on your data, you need the following <a href=\"https://www.tensorflow.org/api_docs/python/tf/dtypes/DType\">float32</a> tensors:\n\n - `features`\n - Placeholder tensor for feature data (`train_features`/`valid_features`/`test_features`)\n - `labels`\n - Placeholder tensor for label data (`train_labels`/`valid_labels`/`test_labels`)\n - `weights`\n - Variable Tensor with random numbers from a truncated normal distribution.\n - See <a href=\"https://www.tensorflow.org/api_docs/python/tf/random/truncated_normal\">`tf.truncated_normal()` documentation</a> for help.\n - `biases`\n - Variable Tensor with all zeros.\n - See <a href=\"https://www.tensorflow.org/api_docs/python/tf/zeros\"> `tf.zeros()` documentation</a> for help.\n\n*If you're having trouble solving problem 2, review \"TensorFlow Linear Function\" section of the class. If that doesn't help, the solution for this problem is available [here](https://github.com/udacity/CarND-TensorFlow-Lab/blob/master/solutions.ipynb).*", "_____no_output_____" ] ], [ [ "features_count = 784\nlabels_count = 10\n\n# TODO: Set the features and labels tensors\nfeatures = tf.placeholder(tf.float32) \nlabels = tf.placeholder(tf.float32) \n\n# TODO: Set the weights and biases tensors\nweights = tf.Variable(tf.truncated_normal((features_count,labels_count)))\nbiases = tf.Variable(tf.zeros(labels_count))\n\n\n\n### DON'T MODIFY ANYTHING BELOW ###\n\n#Test Cases\nfrom tensorflow.python.ops.variables import Variable\n\nassert features._op.name.startswith('Placeholder'), 'features must be a placeholder'\nassert labels._op.name.startswith('Placeholder'), 'labels must be a placeholder'\nassert isinstance(weights, Variable), 'weights must be a TensorFlow variable'\nassert isinstance(biases, Variable), 'biases must be a TensorFlow variable'\n\nassert features._shape == None or (\\\n features._shape.dims[0].value is None and\\\n features._shape.dims[1].value in [None, 784]), 'The shape of features is incorrect'\nassert labels._shape == None or (\\\n labels._shape.dims[0].value is None and\\\n labels._shape.dims[1].value in [None, 10]), 'The shape of labels is incorrect'\nassert weights._variable._shape == (784, 10), 'The shape of weights is incorrect'\nassert biases._variable._shape == (10), 'The shape of biases is incorrect'\n\nassert features._dtype == tf.float32, 'features must be type float32'\nassert labels._dtype == tf.float32, 'labels must be type float32'\n\n# Feed dicts for training, validation, and test session\ntrain_feed_dict = {features: train_features, labels: train_labels}\nvalid_feed_dict = {features: valid_features, labels: valid_labels}\ntest_feed_dict = {features: test_features, labels: test_labels}\n\n# Linear Function WX + b\nlogits = tf.matmul(features, weights) + biases\n\nprediction = tf.nn.softmax(logits)\n\n# Cross entropy\ncross_entropy = -tf.reduce_sum(labels * tf.log(prediction), axis=1)\n\n# some students have encountered challenges using this function, and have resolved issues\n# using https://www.tensorflow.org/api_docs/python/tf/nn/softmax_cross_entropy_with_logits\n# please see this thread for more detail https://discussions.udacity.com/t/accuracy-0-10-in-the-intro-to-tensorflow-lab/272469/9\n\n# Training loss\nloss = tf.reduce_mean(cross_entropy)\n\n# Create an operation that initializes all variables\ninit = tf.global_variables_initializer()\n\n# Test Cases\nwith tf.Session() as session:\n session.run(init)\n session.run(loss, feed_dict=train_feed_dict)\n session.run(loss, feed_dict=valid_feed_dict)\n session.run(loss, feed_dict=test_feed_dict)\n biases_data = session.run(biases)\n\nassert not np.count_nonzero(biases_data), 'biases must be zeros'\n\nprint('Tests Passed!')", "Tests Passed!\n" ], [ "# Determine if the predictions are correct\nis_correct_prediction = tf.equal(tf.argmax(prediction, 1), tf.argmax(labels, 1))\n# Calculate the accuracy of the predictions\naccuracy = tf.reduce_mean(tf.cast(is_correct_prediction, tf.float32))\n\nprint('Accuracy function created.')", "Accuracy function created.\n" ] ], [ [ "<img src=\"image/learn_rate_tune.png\" style=\"height: 60%;width: 60%\">\n\n## Problem 3\nBelow are 3 parameter configurations for training the neural network. In each configuration, one of the parameters has multiple options. For each configuration, choose the option that gives the best acccuracy.\n\nParameter configurations:\n\nConfiguration 1\n* **Epochs:** 1\n* **Batch Size:**\n * 2000\n * 1000\n * 500\n * 300\n * 50\n* **Learning Rate:** 0.01\n\nConfiguration 2\n* **Epochs:** 1\n* **Batch Size:** 100\n* **Learning Rate:**\n * 0.8\n * 0.5\n * 0.1\n * 0.05\n * 0.01\n\nConfiguration 3\n* **Epochs:**\n * 1\n * 2\n * 3\n * 4\n * 5\n* **Batch Size:** 100\n* **Learning Rate:** 0.2\n\nThe code will print out a Loss and Accuracy graph, so you can see how well the neural network performed.\n\n*If you're having trouble solving problem 3, you can view the solution [here](https://github.com/udacity/CarND-TensorFlow-Lab/blob/master/solutions.ipynb).*", "_____no_output_____" ] ], [ [ "# TODO: Find the best parameters for each configuration\nepochs = 30\nbatch_size = 100\nlearning_rate = 0.2\n\n\n\n### DON'T MODIFY ANYTHING BELOW ###\n# Gradient Descent\noptimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss) \n\n# The accuracy measured against the validation set\nvalidation_accuracy = 0.0\n\n# Measurements use for graphing loss and accuracy\nlog_batch_step = 50\nbatches = []\nloss_batch = []\ntrain_acc_batch = []\nvalid_acc_batch = []\n\nwith tf.Session() as session:\n session.run(init)\n batch_count = int(math.ceil(len(train_features)/batch_size))\n\n for epoch_i in range(epochs):\n \n # Progress bar\n batches_pbar = tqdm(range(batch_count), desc='Epoch {:>2}/{}'.format(epoch_i+1, epochs), unit='batches')\n \n # The training cycle\n for batch_i in batches_pbar:\n # Get a batch of training features and labels\n batch_start = batch_i*batch_size\n batch_features = train_features[batch_start:batch_start + batch_size]\n batch_labels = train_labels[batch_start:batch_start + batch_size]\n\n # Run optimizer and get loss\n _, l = session.run(\n [optimizer, loss],\n feed_dict={features: batch_features, labels: batch_labels})\n\n # Log every 50 batches\n if not batch_i % log_batch_step:\n # Calculate Training and Validation accuracy\n training_accuracy = session.run(accuracy, feed_dict=train_feed_dict)\n validation_accuracy = session.run(accuracy, feed_dict=valid_feed_dict)\n\n # Log batches\n previous_batch = batches[-1] if batches else 0\n batches.append(log_batch_step + previous_batch)\n loss_batch.append(l)\n train_acc_batch.append(training_accuracy)\n valid_acc_batch.append(validation_accuracy)\n\n # Check accuracy against Validation data\n validation_accuracy = session.run(accuracy, feed_dict=valid_feed_dict)\n\nloss_plot = plt.subplot(211)\nloss_plot.set_title('Loss')\nloss_plot.plot(batches, loss_batch, 'g')\nloss_plot.set_xlim([batches[0], batches[-1]])\nacc_plot = plt.subplot(212)\nacc_plot.set_title('Accuracy')\nacc_plot.plot(batches, train_acc_batch, 'r', label='Training Accuracy')\nacc_plot.plot(batches, valid_acc_batch, 'x', label='Validation Accuracy')\nacc_plot.set_ylim([0, 1.0])\nacc_plot.set_xlim([batches[0], batches[-1]])\nacc_plot.legend(loc=4)\nplt.tight_layout()\nplt.show()\n\nprint('Validation accuracy at {}'.format(validation_accuracy))", "Epoch 1/30: 100%|██████████| 1425/1425 [00:05<00:00, 241.03batches/s]\nEpoch 2/30: 100%|██████████| 1425/1425 [00:05<00:00, 241.15batches/s]\nEpoch 3/30: 100%|██████████| 1425/1425 [00:05<00:00, 241.68batches/s]\nEpoch 4/30: 100%|██████████| 1425/1425 [00:06<00:00, 237.31batches/s]\nEpoch 5/30: 100%|██████████| 1425/1425 [00:05<00:00, 239.41batches/s]\nEpoch 6/30: 100%|██████████| 1425/1425 [00:06<00:00, 233.95batches/s]\nEpoch 7/30: 100%|██████████| 1425/1425 [00:05<00:00, 248.55batches/s]\nEpoch 8/30: 100%|██████████| 1425/1425 [00:05<00:00, 249.13batches/s]\nEpoch 9/30: 100%|██████████| 1425/1425 [00:05<00:00, 246.91batches/s]\nEpoch 10/30: 100%|██████████| 1425/1425 [00:05<00:00, 246.33batches/s]\nEpoch 11/30: 100%|██████████| 1425/1425 [00:06<00:00, 222.22batches/s]\nEpoch 12/30: 100%|██████████| 1425/1425 [00:05<00:00, 238.46batches/s]\nEpoch 13/30: 100%|██████████| 1425/1425 [00:05<00:00, 247.66batches/s]\nEpoch 14/30: 100%|██████████| 1425/1425 [00:05<00:00, 247.59batches/s]\nEpoch 15/30: 100%|██████████| 1425/1425 [00:05<00:00, 265.48batches/s]\nEpoch 16/30: 100%|██████████| 1425/1425 [00:05<00:00, 243.82batches/s]\nEpoch 17/30: 100%|██████████| 1425/1425 [00:06<00:00, 236.59batches/s]\nEpoch 18/30: 100%|██████████| 1425/1425 [00:05<00:00, 240.60batches/s]\nEpoch 19/30: 100%|██████████| 1425/1425 [00:05<00:00, 248.57batches/s]\nEpoch 20/30: 100%|██████████| 1425/1425 [00:05<00:00, 244.13batches/s]\nEpoch 21/30: 100%|██████████| 1425/1425 [00:05<00:00, 244.86batches/s]\nEpoch 22/30: 100%|██████████| 1425/1425 [00:05<00:00, 217.50batches/s]\nEpoch 23/30: 100%|██████████| 1425/1425 [00:05<00:00, 245.30batches/s]\nEpoch 24/30: 100%|██████████| 1425/1425 [00:05<00:00, 241.40batches/s]\nEpoch 25/30: 100%|██████████| 1425/1425 [00:05<00:00, 251.86batches/s]\nEpoch 26/30: 100%|██████████| 1425/1425 [00:05<00:00, 256.47batches/s]\nEpoch 27/30: 100%|██████████| 1425/1425 [00:06<00:00, 224.38batches/s]\nEpoch 28/30: 100%|██████████| 1425/1425 [00:05<00:00, 249.99batches/s]\nEpoch 29/30: 100%|██████████| 1425/1425 [00:05<00:00, 246.27batches/s]\nEpoch 30/30: 100%|██████████| 1425/1425 [00:05<00:00, 252.18batches/s]\n" ] ], [ [ "## Test\nSet the epochs, batch_size, and learning_rate with the best learning parameters you discovered in problem 3. You're going to test your model against your hold out dataset/testing data. This will give you a good indicator of how well the model will do in the real world. You should have a test accuracy of at least 80%.", "_____no_output_____" ] ], [ [ "# TODO: Set the epochs, batch_size, and learning_rate with the best parameters from problem 3\nepochs = 30\nbatch_size = 100 \nlearning_rate = 0.2\n\n\n\n### DON'T MODIFY ANYTHING BELOW ###\n# The accuracy measured against the test set\ntest_accuracy = 0.0\n\nwith tf.Session() as session:\n \n session.run(init)\n batch_count = int(math.ceil(len(train_features)/batch_size))\n\n for epoch_i in range(epochs):\n \n # Progress bar\n batches_pbar = tqdm(range(batch_count), desc='Epoch {:>2}/{}'.format(epoch_i+1, epochs), unit='batches')\n \n # The training cycle\n for batch_i in batches_pbar:\n # Get a batch of training features and labels\n batch_start = batch_i*batch_size\n batch_features = train_features[batch_start:batch_start + batch_size]\n batch_labels = train_labels[batch_start:batch_start + batch_size]\n\n # Run optimizer\n _ = session.run(optimizer, feed_dict={features: batch_features, labels: batch_labels})\n\n # Check accuracy against Test data\n test_accuracy = session.run(accuracy, feed_dict=test_feed_dict)\n\n\nassert test_accuracy >= 0.80, 'Test accuracy at {}, should be equal to or greater than 0.80'.format(test_accuracy)\nprint('Nice Job! Test Accuracy is {}'.format(test_accuracy))", "Epoch 1/25: 100%|██████████| 1425/1425 [00:02<00:00, 505.22batches/s]\nEpoch 2/25: 100%|██████████| 1425/1425 [00:02<00:00, 540.31batches/s]\nEpoch 3/25: 100%|██████████| 1425/1425 [00:02<00:00, 536.68batches/s]\nEpoch 4/25: 100%|██████████| 1425/1425 [00:02<00:00, 538.19batches/s]\nEpoch 5/25: 100%|██████████| 1425/1425 [00:02<00:00, 539.59batches/s]\nEpoch 6/25: 100%|██████████| 1425/1425 [00:02<00:00, 540.76batches/s]\nEpoch 7/25: 100%|██████████| 1425/1425 [00:02<00:00, 541.74batches/s]\nEpoch 8/25: 100%|██████████| 1425/1425 [00:02<00:00, 545.16batches/s]\nEpoch 9/25: 100%|██████████| 1425/1425 [00:02<00:00, 505.92batches/s]\nEpoch 10/25: 32%|███▏ | 452/1425 [00:00<00:01, 491.61batches/s]" ] ], [ [ "# Multiple layers\nGood job! You built a one layer TensorFlow network! However, you want to build more than one layer. This is deep learning after all! In the next section, you will start to satisfy your need for more layers.", "_____no_output_____" ] ] ]

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

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

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "# Tutorial 6: Dealing with imbalanced dataset using TensorFilter\n\nWhen your dataset is imbalanced, training data needs to maintain a certain distribution to make sure minority classes are not ommitted during the training. In FastEstimator, `TensorFilter` is designed for that purpose.\n\n`TensorFilter` is a Tensor Operator that is used in `Pipeline` along with other tensor operators such as `MinMax` and `Resize`.\n\nThere are only two differences between `TensorFilter` and `TensorOp`: \n1. `TensorFilter` does not have outputs.\n2. The forward function of `TensorFilter` produces a boolean value which indicates whether to keep the data or not.", "_____no_output_____" ], [ "## Step 0 - Data preparation *(same as tutorial 1)*", "_____no_output_____" ] ], [ [ "# Import libraries\nimport numpy as np\nimport tensorflow as tf\nimport fastestimator as fe\nfrom fastestimator.op.tensorop import Minmax\n\n# Load data and create dictionaries\n(x_train, y_train), (x_eval, y_eval) = tf.keras.datasets.mnist.load_data()\ntrain_data = {\"x\": np.expand_dims(x_train, -1), \"y\": y_train}\neval_data = {\"x\": np.expand_dims(x_eval, -1), \"y\": y_eval}\ndata = {\"train\": train_data, \"eval\": eval_data}", "_____no_output_____" ] ], [ [ "## Step 1 - Customize your own Filter...\nIn this example, we will get rid of all images that have a label smaller than 5.", "_____no_output_____" ] ], [ [ "from fastestimator.op.tensorop import TensorFilter\n\n# We create our filter in forward function, it's just our condition.\nclass MyFilter(TensorFilter):\n def forward(self, data, state):\n pass_filter = data >= 5\n return pass_filter\n\n# We specify the filter in Pipeline ops list.\npipeline = fe.Pipeline(batch_size=32, data=data, ops=[MyFilter(inputs=\"y\"), Minmax(inputs=\"x\", outputs=\"x\")])", "_____no_output_____" ], [ "# Let's check our pipeline ops results with show_results\nresults = pipeline.show_results()\nprint(\"filtering out all data with label less than 5, the labels of current batch are:\")\nprint(results[0][\"y\"])", "filtering out all data with label less than 5, the labels of current batch are:\ntf.Tensor([5 9 6 9 8 8 9 6 5 8 9 6 8 9 5 9 6 7 5 8 7 5 7 5 6 6 9 8 6 5 6 5], shape=(32,), dtype=uint8)\n" ] ], [ [ "## ... or use a pre-built ScalarFilter\n\nIn FastEstimator, if user needs to filter out scalar values with a certain probability, one can use pre-built filter `ScalarFilter`. \nLet's filter out even numbers labels with 50% probability:", "_____no_output_____" ] ], [ [ "from fastestimator.op.tensorop import ScalarFilter\n\n# We specify the list of scalars to filter out and the probability to keep these scalars\npipeline = fe.Pipeline(batch_size=32, \n data=data, \n ops=[ScalarFilter(inputs=\"y\", filter_value=[0, 2, 4, 6, 8], keep_prob=[0.5, 0.5, 0.5, 0.5, 0.5]), \n Minmax(inputs=\"x\", outputs=\"x\")])", "_____no_output_____" ], [ "# Let's check our pipeline ops results with show_results\nresults = pipeline.show_results(num_steps=10)\n\nfor idx in range(10):\n batch_label = results[idx][\"y\"].numpy()\n even_count = 0\n odd_count = 0\n for elem in batch_label:\n if elem % 2 == 0:\n even_count += 1\n else:\n odd_count += 1\n print(\"in batch number {}, there are {} odd labels and {} even labels\".format(idx, odd_count, even_count))", "in batch number 0, there are 20 odd labels and 12 even labels\nin batch number 1, there are 21 odd labels and 11 even labels\nin batch number 2, there are 20 odd labels and 12 even labels\nin batch number 3, there are 22 odd labels and 10 even labels\nin batch number 4, there are 22 odd labels and 10 even labels\nin batch number 5, there are 22 odd labels and 10 even labels\nin batch number 6, there are 21 odd labels and 11 even labels\nin batch number 7, there are 20 odd labels and 12 even labels\nin batch number 8, there are 22 odd labels and 10 even labels\nin batch number 9, there are 25 odd labels and 7 even labels\n" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import matplotlib.pyplot as plt\nimport numpy as np\nimport random\nimport pandas as pd\nfrom os import listdir\nfrom sklearn.discriminant_analysis import LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis\nfrom mlxtend.evaluate import scoring", "_____no_output_____" ], [ "def importar_dados(arquivo):\n df = pd.read_csv(arquivo, sep=' ', names=['x1', 'x2', 'classe'])\n \n X = df[['x1', 'x2']].values\n y = df['classe'].values\n \n return X, y", "_____no_output_____" ], [ "def exibir_amostras(X, y, \n titulo=None, \n salvar=False, \n figsize=(10, 8), \n legend_fontsize=20, \n title_fontsize=24, \n labels_fontsize=24, \n ticks_fontsize=16):\n \n classes = list(set([classe for classe in y]))\n n_classes = len(classes)\n \n plt.figure(figsize=figsize)\n \n for classe in classes:\n plt.scatter(X[y == classe][:, 0], X[y == classe][:, 1], s=100, label='Classe ' + str(classe))\n \n plt.legend(fontsize=legend_fontsize)\n plt.grid(True, linestyle='-', alpha=0.5)\n \n plt.title(str(titulo), fontsize=title_fontsize)\n plt.xlabel(r'$x_{1}$', fontsize=labels_fontsize)\n plt.ylabel(r'$x_{2}$', fontsize=labels_fontsize)\n plt.xticks(fontsize=ticks_fontsize)\n plt.yticks(fontsize=ticks_fontsize)\n \n if salvar:\n plt.savefig(titulo + '.pdf', format='pdf', dpi=300, transparent=True, bbox_inches='tight')\n \n plt.show()", "_____no_output_____" ], [ "class AnaliseDiscriminante:\n def __init__ (self, tipo='LDA'):\n self.tipo = tipo\n \n def treinar (self, X, y):\n self.classes = list(set(y))\n self.n_classes = len(self.classes)\n self.n_amostras = len(X)\n self.n_amostras_classe = [len(X[y == c]) for c in self.classes]\n self.probs = [n / self.n_amostras for n in self.n_amostras_classe]\n self.mu = np.mean(X, axis=0)\n self.mu_classe = [np.mean(X[y == c], axis=0) for c in self.classes]\n \n if self.tipo == 'LDA':\n self.sigma = np.cov(X.T)\n self.sigma_inv = np.linalg.inv(self.sigma)\n \n elif self.tipo == 'QDA':\n self.sigma = np.array([np.cov(X[y == c].T) for c in self.classes])\n self.sigma_inv = np.array([np.linalg.inv(matriz) for matriz in self.sigma])\n \n else:\n print(\"O tipo deve ser 'LDA' ou 'QDA'. Escolha um dos dois!\")\n \n def __delta_LDA(self, X, mu, P):\n return (np.matrix(X) * np.matrix(self.sigma_inv).T * np.matrix(mu).T - 0.5 * np.matrix(mu) * np.matrix(self.sigma_inv) * np.matrix(mu).T + np.log(P)).A1[0]\n \n def __delta_QDA(self, X, mu, sigma, sigma_inv, P):\n return (-0.5 * np.log(np.linalg.det(sigma)) - 0.5 * np.matrix(X - mu) * np.matrix(sigma_inv).T * np.matrix(X - mu).T + np.log(P)).A1[0]\n \n def classificar (self, X):\n if self.tipo == 'LDA':\n self.deltas = np.array([[self.__delta_LDA(amostra, self.mu_classe[i], self.probs[i]) for i in range(len(self.classes))] for amostra in X])\n \n elif self.tipo == 'QDA':\n self.deltas = np.array([[self.__delta_QDA(amostra, self.mu_classe[i], self.sigma[i], self.sigma_inv[i], self.probs[i]) for i in range(len(self.classes))] for amostra in X])\n \n else:\n print(\"O tipo deve ser 'LDA' ou 'QDA'. Escolha um dos dois!\")\n \n return np.array([np.argmax(amostra)+1 for amostra in self.deltas])", "_____no_output_____" ], [ "def holdout(X, y, teste_parcela=0.30, aleatorio=True, semente=None):\n n_amostras = len(X)\n n_amostras_teste = int(teste_parcela * n_amostras)\n n_amostras_treino = n_amostras - n_amostras_teste\n\n if aleatorio:\n if semente == None:\n semente = random.randint(0, 1000)\n random.seed(semente)\n teste_idx = np.array(sorted(random.sample(range(n_amostras), n_amostras_teste)))\n\n else:\n teste_idx = np.arange(n_amostras - n_amostras_teste - 1, n_amostras)\n\n treino_idx = np.array(list(set(np.arange(n_amostras)) - set(teste_idx)))\n X_teste = np.array([X[idx] for idx in teste_idx])\n y_teste = np.array([y[idx] for idx in teste_idx])\n X_treino = np.array([X[idx] for idx in treino_idx])\n y_treino = np.array([y[idx] for idx in treino_idx])\n \n return X_treino, y_treino, X_teste, y_teste", "_____no_output_____" ], [ "def avaliar_desempenho(y_verdadeiro, y_obtido):\n return scoring(y_verdadeiro, y_obtido, metric='accuracy', )", "_____no_output_____" ] ], [ [ "### Dataset 1", "_____no_output_____" ] ], [ [ "X1, y1 = importar_dados('datasets/dataset1.txt')\nexibir_amostras(X=X1, y=y1)", "_____no_output_____" ] ], [ [ "**Classificador mais adequado**: para este caso, o LDA já é suficiente para atuar bem, mas nada impede que seja escolhido o QDA.", "_____no_output_____" ] ], [ [ "# Bootstrap\nn_repeticoes = 10\n\nSK_LDA_desempenho = []\nME_LDA_desempenho = []\nSK_QDA_desempenho = []\nME_QDA_desempenho = []\nfor execucao in range(n_repeticoes):\n \n # Holdout\n X_treino, y_treino, X_teste, y_teste = holdout(X=X1, y=y1, teste_parcela=0.30, aleatorio=True, semente=None)\n\n # LDA - Scikit-Learn\n SK_LDA = LinearDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_LDA_y_predito = SK_LDA.predict(X=X_teste)\n SK_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_LDA_y_predito))\n \n # LDA - Próprio\n ME_LDA = AnaliseDiscriminante(tipo='LDA')\n ME_LDA.treinar(X=X_treino, y=y_treino)\n ME_LDA_y_predito = ME_LDA.classificar(X=X_teste)\n ME_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_LDA_y_predito))\n \n # QDA - Scikit-Learn\n SK_QDA = QuadraticDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_QDA_y_predito = SK_QDA.predict(X=X_teste)\n SK_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_QDA_y_predito))\n \n # QDA - Próprio\n ME_QDA = AnaliseDiscriminante(tipo='QDA')\n ME_QDA.treinar(X=X_treino, y=y_treino)\n ME_QDA_y_predito = ME_QDA.classificar(X=X_teste)\n ME_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_QDA_y_predito))\n\nSK_LDA_desempenho = np.array(SK_LDA_desempenho)\nSK_LDA_desempenho_media = np.mean(SK_LDA_desempenho)\nSK_LDA_desempenho_std = np.std(SK_LDA_desempenho)\n\nME_LDA_desempenho = np.array(ME_LDA_desempenho)\nME_LDA_desempenho_media = np.mean(ME_LDA_desempenho)\nME_LDA_desempenho_std = np.std(ME_LDA_desempenho)\n\nSK_QDA_desempenho = np.array(SK_QDA_desempenho)\nSK_QDA_desempenho_media = np.mean(SK_QDA_desempenho)\nSK_QDA_desempenho_std = np.std(SK_QDA_desempenho)\n\nME_QDA_desempenho = np.array(ME_QDA_desempenho)\nME_QDA_desempenho_media = np.mean(ME_QDA_desempenho)\nME_QDA_desempenho_std = np.std(ME_QDA_desempenho)\n\n\nprint('DATASET 1')\nprint('------ Acurácias -----')\nprint('LDA - Scikit: \\t{0:3.4f}'.format(SK_LDA_desempenho_media))\nprint('LDA - Próprio: \\t{0:3.4f}'.format(ME_LDA_desempenho_media))\nprint('----------------------')\nprint('QDA - Scikit: \\t{0:3.4f}'.format(SK_QDA_desempenho_media))\nprint('QDA - Próprio: \\t{0:3.4f}'.format(ME_QDA_desempenho_media))", "DATASET 1\n------ Acurácias -----\nLDA - Scikit: \t1.0000\nLDA - Próprio: \t1.0000\n----------------------\nQDA - Scikit: \t1.0000\nQDA - Próprio: \t1.0000\n" ] ], [ [ "### Dataset 2", "_____no_output_____" ] ], [ [ "X2, y2 = importar_dados('datasets/dataset2.txt')\nexibir_amostras(X=X2, y=y2)", "_____no_output_____" ] ], [ [ "**Classificador mais adequado**: aqui não parece ser possível zerar a taxa de erros, mas é possível observar que o LDA satisfaz a classificação com uma taxa de erros relativamebte baixa.", "_____no_output_____" ] ], [ [ "# Bootstrap\nn_repeticoes = 10\n\nSK_LDA_desempenho = []\nME_LDA_desempenho = []\nSK_QDA_desempenho = []\nME_QDA_desempenho = []\nfor execucao in range(n_repeticoes):\n \n # Holdout\n X_treino, y_treino, X_teste, y_teste = holdout(X=X2, y=y2, teste_parcela=0.30, aleatorio=True, semente=None)\n\n # LDA - Scikit-Learn\n SK_LDA = LinearDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_LDA_y_predito = SK_LDA.predict(X=X_teste)\n SK_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_LDA_y_predito))\n \n # LDA - Próprio\n ME_LDA = AnaliseDiscriminante(tipo='LDA')\n ME_LDA.treinar(X=X_treino, y=y_treino)\n ME_LDA_y_predito = ME_LDA.classificar(X=X_teste)\n ME_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_LDA_y_predito))\n \n # QDA - Scikit-Learn\n SK_QDA = QuadraticDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_QDA_y_predito = SK_QDA.predict(X=X_teste)\n SK_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_QDA_y_predito))\n \n # QDA - Próprio\n ME_QDA = AnaliseDiscriminante(tipo='QDA')\n ME_QDA.treinar(X=X_treino, y=y_treino)\n ME_QDA_y_predito = ME_QDA.classificar(X=X_teste)\n ME_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_QDA_y_predito))\n\nSK_LDA_desempenho = np.array(SK_LDA_desempenho)\nSK_LDA_desempenho_media = np.mean(SK_LDA_desempenho)\nSK_LDA_desempenho_std = np.std(SK_LDA_desempenho)\n\nME_LDA_desempenho = np.array(ME_LDA_desempenho)\nME_LDA_desempenho_media = np.mean(ME_LDA_desempenho)\nME_LDA_desempenho_std = np.std(ME_LDA_desempenho)\n\nSK_QDA_desempenho = np.array(SK_QDA_desempenho)\nSK_QDA_desempenho_media = np.mean(SK_QDA_desempenho)\nSK_QDA_desempenho_std = np.std(SK_QDA_desempenho)\n\nME_QDA_desempenho = np.array(ME_QDA_desempenho)\nME_QDA_desempenho_media = np.mean(ME_QDA_desempenho)\nME_QDA_desempenho_std = np.std(ME_QDA_desempenho)\n\nprint('DATASET 2')\nprint('------ Acurácias -----')\nprint('LDA - Scikit: \\t{0:3.4f}'.format(SK_LDA_desempenho_media))\nprint('LDA - Próprio: \\t{0:3.4f}'.format(ME_LDA_desempenho_media))\nprint('----------------------')\nprint('QDA - Scikit: \\t{0:3.4f}'.format(SK_QDA_desempenho_media))\nprint('QDA - Próprio: \\t{0:3.4f}'.format(ME_QDA_desempenho_media))", "DATASET 2\n------ Acurácias -----\nLDA - Scikit: \t0.7714\nLDA - Próprio: \t0.7429\n----------------------\nQDA - Scikit: \t0.7571\nQDA - Próprio: \t0.7571\n" ] ], [ [ "### Dataset 3", "_____no_output_____" ] ], [ [ "X3, y3 = importar_dados('datasets/dataset3.txt')\nexibir_amostras(X=X3, y=y3)", "_____no_output_____" ] ], [ [ "**Classificador mais adequado**: neste dataset é bastante evidente que há uma intensa sobreposição entre os dados, e o QDA é bem mais conveniente.", "_____no_output_____" ] ], [ [ "# Bootstrap\nn_repeticoes = 10\n\nSK_LDA_desempenho = []\nME_LDA_desempenho = []\nSK_QDA_desempenho = []\nME_QDA_desempenho = []\nfor execucao in range(n_repeticoes):\n \n # Holdout\n X_treino, y_treino, X_teste, y_teste = holdout(X=X3, y=y3, teste_parcela=0.30, aleatorio=True, semente=None)\n\n # LDA - Scikit-Learn\n SK_LDA = LinearDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_LDA_y_predito = SK_LDA.predict(X=X_teste)\n SK_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_LDA_y_predito))\n \n # LDA - Próprio\n ME_LDA = AnaliseDiscriminante(tipo='LDA')\n ME_LDA.treinar(X=X_treino, y=y_treino)\n ME_LDA_y_predito = ME_LDA.classificar(X=X_teste)\n ME_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_LDA_y_predito))\n \n # QDA - Scikit-Learn\n SK_QDA = QuadraticDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_QDA_y_predito = SK_QDA.predict(X=X_teste)\n SK_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_QDA_y_predito))\n \n # QDA - Próprio\n ME_QDA = AnaliseDiscriminante(tipo='QDA')\n ME_QDA.treinar(X=X_treino, y=y_treino)\n ME_QDA_y_predito = ME_QDA.classificar(X=X_teste)\n ME_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_QDA_y_predito))\n\nSK_LDA_desempenho = np.array(SK_LDA_desempenho)\nSK_LDA_desempenho_media = np.mean(SK_LDA_desempenho)\nSK_LDA_desempenho_std = np.std(SK_LDA_desempenho)\n\nME_LDA_desempenho = np.array(ME_LDA_desempenho)\nME_LDA_desempenho_media = np.mean(ME_LDA_desempenho)\nME_LDA_desempenho_std = np.std(ME_LDA_desempenho)\n\nSK_QDA_desempenho = np.array(SK_QDA_desempenho)\nSK_QDA_desempenho_media = np.mean(SK_QDA_desempenho)\nSK_QDA_desempenho_std = np.std(SK_QDA_desempenho)\n\nME_QDA_desempenho = np.array(ME_QDA_desempenho)\nME_QDA_desempenho_media = np.mean(ME_QDA_desempenho)\nME_QDA_desempenho_std = np.std(ME_QDA_desempenho)\n\nprint('DATASET 3')\nprint('------ Acurácias -----')\nprint('LDA - Scikit: \\t{0:3.4f}'.format(SK_LDA_desempenho_media))\nprint('LDA - Próprio: \\t{0:3.4f}'.format(ME_LDA_desempenho_media))\nprint('----------------------')\nprint('QDA - Scikit: \\t{0:3.4f}'.format(SK_QDA_desempenho_media))\nprint('QDA - Próprio: \\t{0:3.4f}'.format(ME_QDA_desempenho_media))", "DATASET 3\n------ Acurácias -----\nLDA - Scikit: \t0.4450\nLDA - Próprio: \t0.4450\n----------------------\nQDA - Scikit: \t0.8033\nQDA - Próprio: \t0.8033\n" ] ], [ [ "### Dataset 4", "_____no_output_____" ] ], [ [ "X4, y4 = importar_dados('datasets/dataset4.txt')\nexibir_amostras(X=X4, y=y4)", "_____no_output_____" ] ], [ [ "**Classificador mais adequado**: aqui também á uma considerável sobreposição das amostras, mas é menos agressiva do que o observado no dataset anterior. Embora não aparente, LDA e QDA exibirão resultados bastante próximos.", "_____no_output_____" ] ], [ [ "# Bootstrap\nn_repeticoes = 10\n\nSK_LDA_desempenho = []\nME_LDA_desempenho = []\nSK_QDA_desempenho = []\nME_QDA_desempenho = []\nfor execucao in range(n_repeticoes):\n \n # Holdout\n X_treino, y_treino, X_teste, y_teste = holdout(X=X4, y=y4, teste_parcela=0.30, aleatorio=True, semente=None)\n\n # LDA - Scikit-Learn\n SK_LDA = LinearDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_LDA_y_predito = SK_LDA.predict(X=X_teste)\n SK_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_LDA_y_predito))\n \n # LDA - Próprio\n ME_LDA = AnaliseDiscriminante(tipo='LDA')\n ME_LDA.treinar(X=X_treino, y=y_treino)\n ME_LDA_y_predito = ME_LDA.classificar(X=X_teste)\n ME_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_LDA_y_predito))\n \n # QDA - Scikit-Learn\n SK_QDA = QuadraticDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_QDA_y_predito = SK_QDA.predict(X=X_teste)\n SK_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_QDA_y_predito))\n \n # QDA - Próprio\n ME_QDA = AnaliseDiscriminante(tipo='QDA')\n ME_QDA.treinar(X=X_treino, y=y_treino)\n ME_QDA_y_predito = ME_QDA.classificar(X=X_teste)\n ME_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_QDA_y_predito))\n\nSK_LDA_desempenho = np.array(SK_LDA_desempenho)\nSK_LDA_desempenho_media = np.mean(SK_LDA_desempenho)\nSK_LDA_desempenho_std = np.std(SK_LDA_desempenho)\n\nME_LDA_desempenho = np.array(ME_LDA_desempenho)\nME_LDA_desempenho_media = np.mean(ME_LDA_desempenho)\nME_LDA_desempenho_std = np.std(ME_LDA_desempenho)\n\nSK_QDA_desempenho = np.array(SK_QDA_desempenho)\nSK_QDA_desempenho_media = np.mean(SK_QDA_desempenho)\nSK_QDA_desempenho_std = np.std(SK_QDA_desempenho)\n\nME_QDA_desempenho = np.array(ME_QDA_desempenho)\nME_QDA_desempenho_media = np.mean(ME_QDA_desempenho)\nME_QDA_desempenho_std = np.std(ME_QDA_desempenho)\n\nprint('DATASET 4')\nprint('------ Acurácias -----')\nprint('LDA - Scikit: \\t{0:3.4f}'.format(SK_LDA_desempenho_media))\nprint('LDA - Próprio: \\t{0:3.4f}'.format(ME_LDA_desempenho_media))\nprint('----------------------')\nprint('QDA - Scikit: \\t{0:3.4f}'.format(SK_QDA_desempenho_media))\nprint('QDA - Próprio: \\t{0:3.4f}'.format(ME_QDA_desempenho_media))", "DATASET 4\n------ Acurácias -----\nLDA - Scikit: \t0.7872\nLDA - Próprio: \t0.7872\n----------------------\nQDA - Scikit: \t0.7564\nQDA - Próprio: \t0.7564\n" ] ], [ [ "### Dataset 5", "_____no_output_____" ] ], [ [ "X5, y5 = importar_dados('datasets/dataset5.txt')\nexibir_amostras(X=X5, y=y5)", "_____no_output_____" ] ], [ [ "**Classificador mais adequado**: este é um caso em que não há qualquer sobreposição. Embora não seja fácil, é possível realizar uma classificação perfeita, com zero erros, utilizando um classificador linear, portanto, o LDA já é suficiente para satisfazer o problema, mas nada impede que o QDA seja utilizado.", "_____no_output_____" ] ], [ [ "# Bootstrap\nn_repeticoes = 10\n\nSK_LDA_desempenho = []\nME_LDA_desempenho = []\nSK_QDA_desempenho = []\nME_QDA_desempenho = []\nfor execucao in range(n_repeticoes):\n \n # Holdout\n X_treino, y_treino, X_teste, y_teste = holdout(X=X5, y=y5, teste_parcela=0.30, aleatorio=True, semente=None)\n\n # LDA - Scikit-Learn\n SK_LDA = LinearDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_LDA_y_predito = SK_LDA.predict(X=X_teste)\n SK_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_LDA_y_predito))\n \n # LDA - Próprio\n ME_LDA = AnaliseDiscriminante(tipo='LDA')\n ME_LDA.treinar(X=X_treino, y=y_treino)\n ME_LDA_y_predito = ME_LDA.classificar(X=X_teste)\n ME_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_LDA_y_predito))\n \n # QDA - Scikit-Learn\n SK_QDA = QuadraticDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_QDA_y_predito = SK_QDA.predict(X=X_teste)\n SK_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_QDA_y_predito))\n \n # QDA - Próprio\n ME_QDA = AnaliseDiscriminante(tipo='QDA')\n ME_QDA.treinar(X=X_treino, y=y_treino)\n ME_QDA_y_predito = ME_QDA.classificar(X=X_teste)\n ME_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_QDA_y_predito))\n\nSK_LDA_desempenho = np.array(SK_LDA_desempenho)\nSK_LDA_desempenho_media = np.mean(SK_LDA_desempenho)\nSK_LDA_desempenho_std = np.std(SK_LDA_desempenho)\n\nME_LDA_desempenho = np.array(ME_LDA_desempenho)\nME_LDA_desempenho_media = np.mean(ME_LDA_desempenho)\nME_LDA_desempenho_std = np.std(ME_LDA_desempenho)\n\nSK_QDA_desempenho = np.array(SK_QDA_desempenho)\nSK_QDA_desempenho_media = np.mean(SK_QDA_desempenho)\nSK_QDA_desempenho_std = np.std(SK_QDA_desempenho)\n\nME_QDA_desempenho = np.array(ME_QDA_desempenho)\nME_QDA_desempenho_media = np.mean(ME_QDA_desempenho)\nME_QDA_desempenho_std = np.std(ME_QDA_desempenho)\n\nprint('DATASET 5')\nprint('------ Acurácias -----')\nprint('LDA - Scikit: \\t{0:3.4f}'.format(SK_LDA_desempenho_media))\nprint('LDA - Próprio: \\t{0:3.4f}'.format(ME_LDA_desempenho_media))\nprint('----------------------')\nprint('QDA - Scikit: \\t{0:3.4f}'.format(SK_QDA_desempenho_media))\nprint('QDA - Próprio: \\t{0:3.4f}'.format(ME_QDA_desempenho_media))", "DATASET 5\n------ Acurácias -----\nLDA - Scikit: \t0.9889\nLDA - Próprio: \t0.9800\n----------------------\nQDA - Scikit: \t0.9844\nQDA - Próprio: \t0.9844\n" ] ], [ [ "### Dataset 6", "_____no_output_____" ] ], [ [ "X6, y6 = importar_dados('datasets/dataset6.txt')\nexibir_amostras(X=X6, y=y6)", "_____no_output_____" ] ], [ [ "**Classificador mais adequado**: neste caso já há sobreposição, o que não permite uma classificação completamente isenta de erros, mas um bom desempenho pode ser alcançado por ambos os classificadores, sem que haja grandes diferenças entre eles.", "_____no_output_____" ] ], [ [ "# Bootstrap\nn_repeticoes = 10\n\nSK_LDA_desempenho = []\nME_LDA_desempenho = []\nSK_QDA_desempenho = []\nME_QDA_desempenho = []\nfor execucao in range(n_repeticoes):\n \n # Holdout\n X_treino, y_treino, X_teste, y_teste = holdout(X=X6, y=y6, teste_parcela=0.30, aleatorio=True, semente=None)\n\n # LDA - Scikit-Learn\n SK_LDA = LinearDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_LDA_y_predito = SK_LDA.predict(X=X_teste)\n SK_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_LDA_y_predito))\n \n # LDA - Próprio\n ME_LDA = AnaliseDiscriminante(tipo='LDA')\n ME_LDA.treinar(X=X_treino, y=y_treino)\n ME_LDA_y_predito = ME_LDA.classificar(X=X_teste)\n ME_LDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_LDA_y_predito))\n \n # QDA - Scikit-Learn\n SK_QDA = QuadraticDiscriminantAnalysis().fit(X=X_treino, y=y_treino)\n SK_QDA_y_predito = SK_QDA.predict(X=X_teste)\n SK_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=SK_QDA_y_predito))\n \n # QDA - Próprio\n ME_QDA = AnaliseDiscriminante(tipo='QDA')\n ME_QDA.treinar(X=X_treino, y=y_treino)\n ME_QDA_y_predito = ME_QDA.classificar(X=X_teste)\n ME_QDA_desempenho.append(avaliar_desempenho(y_verdadeiro=y_teste, y_obtido=ME_QDA_y_predito))\n\nSK_LDA_desempenho = np.array(SK_LDA_desempenho)\nSK_LDA_desempenho_media = np.mean(SK_LDA_desempenho)\nSK_LDA_desempenho_std = np.std(SK_LDA_desempenho)\n\nME_LDA_desempenho = np.array(ME_LDA_desempenho)\nME_LDA_desempenho_media = np.mean(ME_LDA_desempenho)\nME_LDA_desempenho_std = np.std(ME_LDA_desempenho)\n\nSK_QDA_desempenho = np.array(SK_QDA_desempenho)\nSK_QDA_desempenho_media = np.mean(SK_QDA_desempenho)\nSK_QDA_desempenho_std = np.std(SK_QDA_desempenho)\n\nME_QDA_desempenho = np.array(ME_QDA_desempenho)\nME_QDA_desempenho_media = np.mean(ME_QDA_desempenho)\nME_QDA_desempenho_std = np.std(ME_QDA_desempenho)\n\nprint('DATASET 6')\nprint('------ Acurácias -----')\nprint('LDA - Scikit: \\t{0:3.4f}'.format(SK_LDA_desempenho_media))\nprint('LDA - Próprio: \\t{0:3.4f}'.format(ME_LDA_desempenho_media))\nprint('----------------------')\nprint('QDA - Scikit: \\t{0:3.4f}'.format(SK_QDA_desempenho_media))\nprint('QDA - Próprio: \\t{0:3.4f}'.format(ME_QDA_desempenho_media))", "DATASET 6\n------ Acurácias -----\nLDA - Scikit: \t0.8222\nLDA - Próprio: \t0.8089\n----------------------\nQDA - Scikit: \t0.8156\nQDA - Próprio: \t0.8156\n" ] ] ]

[ "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", "code", "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/ibzan79/daa_2021_1/blob/master/7Octubre_daa.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ], [ "# Búsqueda lineal\n\nDada un conjunto de datos no ordenados, la búsqueda lineal consiste en recorrer el conjunto de datos desde el inicio al final, moviéndose uno en uno hasta encontrar el elemento o llegar al final del conjunto.\n\ndatos = [ 4,18,47,2,34,14,78,12,48,21,31,19,1,3,5 ]\n\n# Búsqueda binaria\nfunciona sobre un conjunto de datos lineal ordenado.\n\nConsiste en dividir el conjunto en mitades y buscar en esa mitad. Si el elemento buscado no está en la mitad, preguntas si el elemento está a la derecha o a la izquierda. Haces la lista igual a la mitad correspondiente y repites el proceso.\n\nPseudocódigo:\n\nL = [ 4,18,47,2,34,14,78,12,48,21,31,19,1,3,5]\n\nDER = longitud(L) - 1\n\nIZQ = 0\n\nMID: apuntará a la mitad del segmento de búsqueda \n\nbuscado: es el valos a buscar\n\n1. Hacer DER = longitud(L) - 1\n2. Hacer IZQ = 0\n3. Si IZQ > DER, significa que hay un error en los datos \n4. Calcular MID = int((IZQ + DER) / 2)\n5. Mientras L[MID] != buscado, hacer\n6. - preguntar si L[MID] > buscado \n - hacer DER = MID\n - de lo contrario\n - hacer IZQ = MID\n - preguntar si (DER - IZQ) % 2 == 0\n - MID = (IZQ + ((DER - IZQ) / 2)) + 1\n - de lo contrario\n - MID = IZQ + ((DER - IZQ) / 2)\n7. return MID", "_____no_output_____" ] ], [ [ "'''\nBusqueda lineal\nregresa la posición del elemento 'buscado' si se encuentra dentro de la lista.\nregresa -1 si el elemento buscado no existe dentro de la lista.\n'''\ndef busq_lineal(L, buscado):\n indice = -1\n contador = 0\n for idx in range(len(L)):\n contador += 1\n if L[idx] == buscado:\n indice = idx\n break\n print(f\"número de comparaciones realizadas = {contador}\")\n return indice\n\n'''\nBúsqueda binaria\n'''\n\ndef busqueda_binaria(L, buscado):\n IZQ = 0\n DER = len(L) - 1\n MID = int((IZQ + DER) / 2)\n if len(L) % 2 == 0:\n MID = (DER // 2) + 1\n else:\n MID = DER // 2\n while (L[MID] != buscado):\n if L[MID] > buscado:\n DER = MID\n else:\n IZQ = MID\n if (DER - IZQ) % 2 == 0:\n MID = (IZQ + ((DER - IZQ) // 2)) + 1\n else:\n MID = IZQ + ((DER - IZQ) // 2)\n return MID\n\ndef main():\n datos = [ 4,18,47,2,34,14,78,12,48,21,31,19,1,3,5]\n dato = int(input(\"Que valor quieres buscar: \"))\n resultado = busq_lineal(datos, dato)\n print(\"Resultado: \", resultado)\n\n print(\"Búsqueda lineal en una lista ordenada\")\n datos.sort() # Con esto se ordenan los datos\n print(datos)\n resultado = busq_lineal(datos, dato)\n print(\"Resultado: \", resultado)\n\n print(\"Búsqueda binaria\")\n posicion = busqueda_binaria(datos, dato)\n print(f\"El elemento dato está en la posición {posicion} de la lista\")\n\nmain()", "Que valor quieres buscar: 47\nnúmero de comparaciones realizadas = 3\nResultado: 2\nBúsqueda lineal en una lista ordenada\n[1, 2, 3, 4, 5, 12, 14, 18, 19, 21, 31, 34, 47, 48, 78]\nnúmero de comparaciones realizadas = 13\nResultado: 12\nBúsqueda binaria\n" ] ] ]

[ "markdown", "code" ]

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

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "\nimport base64\nimport json\nimport os\nimport requests\n\n\nBASE_URL = os.environ.get('BASE_URL')\nAPI_KEY = os.environ.get('API_KEY')\nAPI_SECRET = os.environ.get('API_SECRET')", "_____no_output_____" ], [ "credentials_concatenated = ':'.join((API_KEY, API_SECRET))\ncredentials_encoded = base64.b64encode(credentials_concatenated.encode('utf-8'))\naccess_url = f'{BASE_URL}/oauth/token'\n\naccess_headers = {\n 'Authorization': b'Basic ' + credentials_encoded\n}\n\naccess_params = {\n 'grant_type': 'client_credentials'\n}\n\nresponse = requests.post(access_url, headers=access_headers, data=access_params)\n\nif response.ok:\n response_json = response.json()\n print(response_json['access_token'])\nelse:\n raise Exception(\"Failed to retrieve access token\")\n", "_____no_output_____" ], [ "with open('nwea.json') as json_file:\n data = json.load(json_file)\n\n\ndata['Bootstraps']", "_____no_output_____" ] ] ]

[ "code" ]

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

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ "Apache-2.0" ]

[ [ [ "import numpy as np\nimport pandas as pd", "_____no_output_____" ], [ "np.random.seed(0) # pour éviter le changement de la matrice à chaque recompilation\nA = np.random.randint(0,9, [5,4])\nA", "_____no_output_____" ], [ "A.mean()", "_____no_output_____" ], [ "A.std()", "_____no_output_____" ], [ "A.var()", "_____no_output_____" ], [ "A.shape", "_____no_output_____" ], [ "A.max()", "_____no_output_____" ], [ "A.min()", "_____no_output_____" ], [ "A.argmin()", "_____no_output_____" ], [ "A.argmax()", "_____no_output_____" ], [ "np.corrcoef(A)", "_____no_output_____" ], [ "A", "_____no_output_____" ], [ "np.unique(A, return_counts=True)", "_____no_output_____" ], [ "values, counts = np.unique(A,return_counts=True)", "_____no_output_____" ], [ "values", "_____no_output_____" ], [ "counts", "_____no_output_____" ], [ "counts.argsort()", "_____no_output_____" ], [ "C = counts[counts.argsort()]\nC", "_____no_output_____" ], [ "D =values[counts.argsort()]\nD", "_____no_output_____" ], [ "for i, j in zip(C, D) :\n print(f'L\\'élement {j} apparait {i} fois dans la matrice A')", "L'élement 0 apparait 1 fois dans la matrice A\nL'élement 2 apparait 1 fois dans la matrice A\nL'élement 4 apparait 1 fois dans la matrice A\nL'élement 1 apparait 2 fois dans la matrice A\nL'élement 6 apparait 2 fois dans la matrice A\nL'élement 3 apparait 3 fois dans la matrice A\nL'élement 5 apparait 3 fois dans la matrice A\nL'élement 8 apparait 3 fois dans la matrice A\nL'élement 7 apparait 4 fois dans la matrice A\n" ], [ "# counts.sort()\n# counts", "_____no_output_____" ], [ "[A>4]", "_____no_output_____" ], [ "E = np.random.randn(4,3)\nE", "_____no_output_____" ], [ "E[E>0.5] = np.nan\nE", "_____no_output_____" ], [ "E.mean()", "_____no_output_____" ], [ "np.nanmean(E)", "_____no_output_____" ], [ "np.nanstd(E)", "_____no_output_____" ], [ "np.nanvar(E)", "_____no_output_____" ], [ "np.isnan(E)", "_____no_output_____" ], [ "l = np.isnan(E).sum()\nl", "_____no_output_____" ], [ "l/E.size", "_____no_output_____" ], [ "E.shape", "_____no_output_____" ], [ "E.size", "_____no_output_____" ], [ "E[np.isnan(E)] = 0", "_____no_output_____" ], [ "E", "_____no_output_____" ] ], [ [ "# Algèbre linéaire", "_____no_output_____" ] ], [ [ "M = np.random.randint(0,9, [4,3])\nprint(M) \nprint('\\n')\nN =np.random.randint(0,9, [3,4])\nprint(N)", "[[8 4 6]\n [5 8 2]\n [3 7 5]\n [3 4 5]]\n\n\n[[3 3 7 7]\n [3 2 3 7]\n [7 5 1 2]]\n" ], [ "M.dot(N)", "_____no_output_____" ], [ "N.dot(M)", "_____no_output_____" ], [ "M.T", "_____no_output_____" ], [ "G = np.random.randint(0,9,[3,3])", "_____no_output_____" ], [ "np.linalg.det(G)", "_____no_output_____" ], [ "np.linalg.inv(G)", "_____no_output_____" ], [ "np.linalg.pinv(G)", "_____no_output_____" ], [ "np.linalg.pinv(M)", "_____no_output_____" ], [ "np.linalg.eig(G)", "_____no_output_____" ] ], [ [ "# TP Standardisation (important)", "_____no_output_____" ] ], [ [ "M", "_____no_output_____" ], [ "M.mean(axis=0)", "_____no_output_____" ], [ "P= M - M.mean(axis=0)\nP", "_____no_output_____" ], [ "S = P/M.std(axis=0)\nS # standardisation", "_____no_output_____" ] ] ]

[ "code", "markdown", "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", "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code", "code", "code", "code", "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# High Pass Filter Using the Spectral Reversal Technique\nWe can create a high pass filter by using as reference a low pass filter and a technique called **Spectral Reversal**. For this notebook we will use the *Windowed-Sinc Filters* Notebook results, which are pickled in an serialized object called `save_data.pickle`.", "_____no_output_____" ] ], [ [ "import sys\nsys.path.insert(0, '../')", "_____no_output_____" ], [ "from Common import common_plots\nfrom Common import fourier_transform\n\ncplots = common_plots.Plot()", "_____no_output_____" ], [ "import pickle\nimport numpy as np\nimport matplotlib.pyplot as plt", "_____no_output_____" ], [ "def get_fourier(x):\n \"\"\"\n Function that performs the Fourier calculation of a signal x and returns its magnitude and frequency range.\n \n Parameters:\n x (numpy array): Signal to be transformed into Fourier domain.\n \n Returns:\n mag (numpy array): Magnitude of the signal's Fourier transform.\n freq (numpy array): Frequency domain of the signal's Fourier transform.\n \"\"\"\n signal = x.reshape(-1,1)\n fourier = fourier_transform.FourierTransform(signal)\n mag = fourier.dft_magnitude()\n freq = fourier.frequency_domain()\n return mag, freq", "_____no_output_____" ] ], [ [ "We load the low pass data from the *Windowed-Sinc Filters* Notebook", "_____no_output_____" ] ], [ [ "with open('save_data.pickle', 'rb') as f:\n data = pickle.load(f)\n \necg = np.array(data['ecg'])\nlow_pass = np.array(data['low_pass'])\nlow_pass = low_pass/np.sum(low_pass)\nfft_low_pass = np.array(data['fft_low_pass'])", "_____no_output_____" ] ], [ [ "To generate the high pass filter, we use the Sprectral Reversal methond, which consist of multiplying the low pass filter response $h_{lp}[n]$ with $(-1)^{-n}$. Therefore the high pass filter response is given by:\n$$h_{hp}[n] = h_{lp}[n](-1)^{-n}$$", "_____no_output_____" ] ], [ [ "N = low_pass.shape[0]\nhigh_pass = low_pass * ((-1) ** np.arange(N))", "_____no_output_____" ], [ "dft_low_pass_magnitude, dft_low_pass_freq = get_fourier(low_pass)\ndft_high_pass_magnitude, dft_high_pass_freq = get_fourier(high_pass)", "_____no_output_____" ], [ "plt.rcParams[\"figure.figsize\"] = (15,10)\n\nplt.subplot(2,2,1)\nplt.stem(low_pass, markerfmt='.', use_line_collection=True)\nplt.title('Low Pass Filter')\nplt.grid('on')\n\nplt.subplot(2,2,2)\nplt.stem(high_pass, markerfmt='.', use_line_collection=True)\nplt.title('High Pass Filter')\nplt.grid('on')\n\nplt.subplot(2,2,3)\ncplots.plot_frequency_response(dft_low_pass_magnitude, \n dft_low_pass_freq, \n title='Low Pass Filter Response')\n\nplt.subplot(2,2,4)\ncplots.plot_frequency_response(dft_high_pass_magnitude, \n dft_high_pass_freq, \n title='High Pass Filter Response');", "_____no_output_____" ] ], [ [ "**This frequency response is a “left-right flipped” version of the frequency response of the low-pass filter.**", "_____no_output_____" ] ], [ [ "low_pass_ecg = np.convolve(ecg,low_pass)\nhigh_pass_ecg = np.convolve(ecg,high_pass)\n\n\nplt.rcParams[\"figure.figsize\"] = (15,10)\n\nplt.subplot(2,2,1)\nplt.plot(low_pass_ecg)\nplt.title('Low Pass ECG')\nplt.grid('on')\nplt.xlabel('Samples')\nplt.ylabel('Amplitude')\n\nplt.subplot(2,2,2)\nplt.plot(high_pass_ecg)\nplt.title('High Pass ECG')\nplt.grid('on')\nplt.xlabel('Samples')\nplt.ylabel('Amplitude')\n\nplt.subplot(2,1,2)\nplt.plot(ecg)\nplt.title('ECG Signal')\nplt.grid('on')\nplt.xlabel('Samples')\nplt.ylabel('Amplitude');", "_____no_output_____" ] ], [ [ "## Why Does Spectral Reversal Work?\n\nThe spectral reversal technique is based on the so-called shift theorem of the Fourier transform. Formulated for the discrete case, the shift theorem says that, for a Fourier transform pair $x[n]⟷X[k]$, a shift by $s$ samples in the frequency domain is equivalent with multiplying by a complex exponential in the time domain, as\n\n$$x[n]e^{j2πns/N}⟷X[k−s]$$\n\nIn general, the result of doing this will be complex. This is not a problem, but let’s investigate in which circumstances the result is not complex. This is may be easiest to see with the complex exponential rewritten using Euler’s Identity,\n\n$$e^{j2πns/N}=\\cos{(2πns/N)}+j\\sin{(2πns/N)}$$\n\nThis expression is real if the sine term is zero, which is the case if the angle is zero or $\\pi$\n\nWe get this result if we shift by $s=N/2$ samples, because then the angles become $2πns/N=nπ$. Of course, in that case the complete expression becomes $\\cos{(nπ)}$, which is exactly the sequence $1,−1,1,−1,…$.", "_____no_output_____" ], [ "#### Reference:\n[1] https://tomroelandts.com/articles/spectral-reversal-to-create-a-high-pass-filter", "_____no_output_____" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "empty" ] ] ]

[ "empty" ]

[ [ "empty" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<a href=\"https://colab.research.google.com/github/kpflugshaupt/colab/blob/master/First_try.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>", "_____no_output_____" ] ], [ [ "import pandas as pd\n", "_____no_output_____" ], [ "", "_____no_output_____" ] ], [ [ "", "_____no_output_____" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import pandas as pd", "_____no_output_____" ], [ "data=pd.read_csv('data.csv')", "_____no_output_____" ], [ "data.isnull().sum()", "_____no_output_____" ], [ "data.head()", "_____no_output_____" ], [ "data = data.drop('User ID', axis=1)", "_____no_output_____" ], [ "data.head()", "_____no_output_____" ], [ "from sklearn.preprocessing import LabelEncoder", "_____no_output_____" ], [ "le= LabelEncoder()", "_____no_output_____" ], [ "data['Gender']=le.fit_transform(data['Gender'])", "_____no_output_____" ], [ "data.head()", "_____no_output_____" ], [ "import matplotlib.pyplot as plt\nimport seaborn as sns\n", "_____no_output_____" ], [ "sns.pairplot(data)", "_____no_output_____" ], [ "x=data.drop('Purchased',axis=1).values\ny=data['Purchased'].values", "_____no_output_____" ], [ "x.shape,y.shape", "_____no_output_____" ], [ "from sklearn.model_selection import train_test_split", "_____no_output_____" ], [ "x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.2,shuffle=True)", "_____no_output_____" ], [ "x_train.shape,y_train.shape,x_test.shape,y_test.shape", "_____no_output_____" ], [ "from sklearn.linear_model import LogisticRegression", "_____no_output_____" ], [ "log=LogisticRegression()", "_____no_output_____" ], [ "log.fit(x_train,y_train)", "_____no_output_____" ], [ "pred = log.predict(x_test)", "_____no_output_____" ], [ "from sklearn.metrics import accuracy_score", "_____no_output_____" ], [ "accuracy_score(y_test,pred)", "_____no_output_____" ], [ "plt.plot(pred, '--r')\nplt.plot(y_test, '-b')\nplt.title('Pur vs Act')\nplt.show()", "_____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" ] ]

[ "CC0-1.0" ]

[ "CC0-1.0" ]

[ "CC0-1.0" ]

[ [ [ "# Bubble dissolution : Realtime Acquisition + Preprocessing + Saving Data / Snapshots\n\nBrice : [email protected]", "_____no_output_____" ], [ "## Step 1 : Definitions / Initialisations / Automatic thresholding\n\n#### Subroutines : \n\n* `analyse_bubble` : checks one bubble (any bubble) for shape and threshold detection\n * `padding` : pads an image with values from the edge (useful to avoid issues with bubbles close to the border)\n * `proj_fourier` : fits the bubble shape with Fourier series (produces coefficients)\n * `build_fourier` : rebuilds the Fourier fit based on projection coefficients\n* `write_csvheader` : helps me build a nice header for the data file based on \n* `write_logheader`: helps doing the same with the log file (saving lots of acquisition-related parameters)\n* `format_logstr` : bunches together some numbers to track your experiment (in log file & in stdout)\n* `init_figure` : initialises the (somewhat live) figure of the bubble and its interface\n* `init_camera` : (re)starts the camera with the proper acquisition parameters\n\n#### Note : \n\nIf the camera is not accessible, try before re-running the cells : \n\n* camera.Close() \n* closing vscode and restarting it\n* Closing Pylon :-)\n\n\n ", "_____no_output_____" ] ], [ [ "from pypylon import pylon\nfrom bokeh.plotting import show, row, figure, column\nfrom bokeh.models import ColumnDataSource, LinearColorMapper\nfrom jupyter_bokeh.widgets import BokehModel\nfrom bokeh.io import output_notebook\nimport numpy as np\nimport pandas as pd\nimport time\nimport codecs\nimport os\nfrom PIL import Image\nimport skimage.transform as sktr\nimport skimage.measure as skms\nimport skimage.filters as skfi\nimport skimage.morphology as skmph\n\n##### YOUR PARAMETERS HERE #############\n\nzoom = 3 # Check on the lens\n## ZOOM VALUES z = {'zoom': [0.7, 1, 1.5, 2, 3, 4, 4.5], 'one_mm_in_px': [62, 91, 137, 184, 281, 361, 405]}\n## Leads to 90.4 mm/px for a zoom of 1\nexposure = 100 # in ms\nimagesize = [512,512] # width x height\nfilter_size = 1 # To smooth images\nfolder_location = 'C:\\\\Users\\\\saint-michel\\\\Documents\\\\Acquisitions\\\\Bubbles_20211216'\npixel_format = \"Mono12\" # Image values are then from 0 to 4095 (and not 255). NOTE : SOME THINGS WILL BREAK IF YOU CHANGE THIS (including image saving)\nthreshold = None # From 0 to 4096, leave to 'None' if you want auto threshold ...\nchunk_size = 100 # We save snapshots every chunk_size frames \n\n### FUNCTIONS THAT YOU MAY CALL TO DO THINGS ##################################################################\ndef analyse_frame(img, myinfo, time=0):\n # Finds a nice threshold, etc. \n # Myinfo : dict with at least 'pixel_format' and 'threshold' (which can be None)\n # Time : timestamp given by camera.grabFrame\n # Subroutines ... \n def img_padding(img, pad=16):\n img_pad = np.zeros((np.shape(img)[0] + 2*pad, np.shape(img)[1] + 2*pad))\n img_pad[pad:-pad, pad:-pad] = img\n img_pad[:pad, pad:-pad] = img[0,:]\n img_pad[-pad:, pad:-pad] = img[-1,:]\n img_pad[:, :pad] = img_pad[:,pad, np.newaxis]\n img_pad[:, -pad:] = img_pad[:, -pad-1, np.newaxis]\n return img_pad, pad\n def proj_fourier(signal, thetas):\n nmodes = 10\n proj_cos, proj_sin = np.zeros(nmodes), np.zeros(nmodes)\n for mno in range(nmodes):\n proj_cos[mno] = np.trapz(signal*np.cos(mno*thetas), x=thetas)*1/np.pi\n proj_sin[mno] = np.trapz(signal*np.sin(mno*thetas), x=thetas)*1/np.pi\n proj_amp = np.sqrt(proj_cos**2 + proj_sin**2)\n proj_phs = np.arctan2(-proj_sin, proj_cos) # It works with a (-) ... so be it.\n return proj_amp, proj_phs\n def build_fourier(proj_amp, proj_phs, thetas):\n nmodes = 10\n rebuild = np.zeros(np.shape(thetas))\n for mno in range(nmodes):\n rebuild = rebuild + proj_amp[mno]*np.cos(mno*thetas + proj_phs[mno])\n return rebuild\n def local_minimum(signal, size=150):\n x = np.linspace(-3,3,size+1)\n kernel = np.diff(np.exp(-x**2))/np.sum(np.exp(-x**2))\n signal_dfilt = np.convolve(signal, kernel, mode='same')\n slope_left, slope_right = signal_dfilt[:-1], signal_dfilt[1:]\n the_maxima = np.where(np.logical_and(slope_left > 0, slope_right < 0))[0]\n if the_maxima.size == 2:\n the_minimum = np.round(0.5*np.sum(the_maxima)).astype(int)\n print('> local_minimum : Found two maxima at : ' + str(the_maxima) + ' / minimum around : ' + str(the_minimum))\n return the_minimum\n else:\n print(\"> Cannot locate a minimum between : \" + str(np.size(the_maxima)) + ' maxima :(' )\n return 0 \n\n # fill holes & filter image\n img_seed = np.copy(img)\n img_seed[1:-1,1:-1] = img.min()\n img_filled = skmph.reconstruction(img_seed, img, method='dilation')\n img_pad, padsize = img_padding(img_filled, pad=16)\n img_filt = skfi.gaussian(img_pad, sigma=myinfo['smoothing'], preserve_range=True)\n myinfo['padsize'] = padsize\n\n # Find threshold from histogram, then threshold image and analyse it\n [hist, bins] = np.histogram(img_filt.ravel(), bins=np.linspace(-0.5,myinfo['max_lum']+0.5, 361)) # NOTE: bin number must mach length of theta (for bokeh CDS to be happy)\n if myinfo['threshold'] is None:\n myinfo['threshold'] = bins[local_minimum(hist)]\n img_th = img_pad < myinfo['threshold']\n labelled_img = skms.label(img_th)\n props = skms.regionprops_table(labelled_img, properties=('label', 'centroid', 'area', 'eccentricity', 'coords'))\n big = props['area'] > 100\n\n # Fill in small objects, clean up a bit\n x_toclean, y_toclean = np.array([], dtype=int), np.array([], dtype=int)\n for elno, xy in enumerate(props['coords']):\n if not big[elno]:\n x_toclean, y_toclean = np.append(x_toclean, xy[:,1]), np.append(y_toclean, xy[:,0])\n img_th[y_toclean, x_toclean] = 0\n props = pd.DataFrame.from_dict(props).drop(columns='coords')\n props = props[big].sort_values(by='area', ascending=False, ignore_index=True)\n props['label'] = np.arange(1,props.shape[0]+1)\n\n # If no objects, we can't analyse interface (== project on polar coordinates + do fourier modes)\n th_rebuild = np.linspace(-np.pi, np.pi, 360)\n nbubbles = np.size(props['area'])\n adapter = np.atleast_1d(np.ones(np.shape(props['area']))) # matching shape of rad, ecc, ... with scalar frameno & time\n local_time = (time - myinfo['reftime'])*1e-9\n\n if nbubbles > 0:\n # These will be saved later\n xctr, yctr = np.atleast_1d(props['centroid-1']), np.atleast_1d(props['centroid-0'])\n rad, ecc, label = np.atleast_1d(np.sqrt(props['area']/np.pi)), np.atleast_1d(props['eccentricity']), np.atleast_1d(props['label'])\n frameno, time = adapter*idx, adapter*local_time\n\n # This is not saved later, just used to check interface of the largest bubble (and verify threshold)\n bub0 = np.argmax(rad) \n img_pad_warp = sktr.warp_polar(img_pad, (yctr[bub0], xctr[bub0]), radius=1.4*rad[bub0]).T\n img_th_warp = sktr.warp_polar(img_th, (yctr[bub0], xctr[bub0]), radius=1.4*rad[bub0]).T\n coords = skms.find_contours(img_th)\n longest_contour = np.argmax([elem.shape[0] for elem in coords])\n coords = np.array(coords[longest_contour]) # I expect the longest contour to match the largest object ...\n coords = (coords - [yctr[bub0], xctr[bub0]])/rad[bub0] # Normally : only one contour\n th, r = np.arctan2(coords[:,0], coords[:,1]), np.sqrt(coords[:,0]**2 + coords[:,1]**2) - 1\n reorder = np.argsort(th)\n th, r = th[reorder], r[reorder]\n r_amps, r_phs = proj_fourier(r, th)\n img_pad_diff = skfi.gaussian(np.diff(img_pad_warp, axis=0), sigma=1)\n r_fit = 1 + build_fourier(r_amps, r_phs, th_rebuild)\n r_maxgrad = (np.argmax(img_pad_diff, axis=0) + 0.5)*1.4/np.shape(img_pad_warp)[0]\n else:\n img_pad_warp, img_th_warp = np.zeros((200, 360)), np.zeros((200, 360))\n r_fit, r_maxgrad = np.zeros(360), np.zeros(360)\n xctr, yctr, rad, ecc, = np.array([np.nan]), np.array([np.nan]), np.array([np.nan]), np.array([np.nan]) \n label, time, frameno = np.array([0]), np.array([local_time]), np.array([idx])\n\n # Putting everything in two dicts because there is a bug in Bokeh if singleton and 1d objects are mixed\n img_data = {'img': [img_pad], 'img_th': [img_th], 'img_polar': [img_pad_warp], 'img_th_polar': [img_th_warp], \n 'frame': frameno, 'time': time, 'label': label, 'x_px':xctr, 'y_px':yctr, 'rad':rad, 'ecc':ecc, 'padsize':[padsize]}\n line_data = {'theta': th_rebuild, 'r_fourier': r_fit, 'r_gradient': r_maxgrad, 'lum_hist': hist, 'lum_bins': bins[1:]}\n\n return img_data, line_data\n\n### WRITE HEADER OF FILES OR DATA #################################################\ndef write_csvheader(myfile, mylist):\n mystr = ''\n for elem in mylist:\n mystr += elem + ',' \n myfile.write(mystr[:-1] + '\\n')\n return 0\n\ndef write_logheader(myfile, mydict):\n for k, v in zip(mydict.keys(), mydict.values()):\n info_str = str(k) + ':' + str(v) + '\\n'\n myfile.write(info_str)\n print(info_str,end='')\n return 0\n\ndef format_data(data_dict, myinfo): # Data_dict is essentially img_data (or CDS_img.data)\n nrows, ncols = np.shape(data_dict['x_px'])[0], 8\n is_spurious = np.any(np.sum(data_dict['img'], axis=1) == 0) # Spurious == strange horizontal black lines\n data = np.zeros((nrows, ncols))\n\n if nrows > 0:\n data[:,0] = data_dict['frame']\n data[:,1] = data_dict['time']\n data[:,2] = data_dict['label']\n data[:,3] = data_dict['x_px']*myinfo['pixsize']\n data[:,4] = data_dict['y_px']*myinfo['pixsize']\n data[:,5] = data_dict['rad']*myinfo['pixsize']\n data[:,6] = data_dict['ecc']\n data[:,7] = is_spurious \n return data\n\ndef format_logstr(data_dict):\n is_spurious = np.any(np.sum(data_dict['img'], axis=1) == 0) # Spurious == strange horizontal black lines\n nstr = 'Frame=' + '{:06.0f}'.format(data_dict['frame'][0]) + ','\n tstr = 't=' + '{:.2f}'.format(data_dict['time'][0]) + ','\n labstr = 'n=' + '{:.0f}'.format(data_dict['label'][-1]) + ','\n xstr = 'x0=' + '{:.2f}'.format(data_dict['x_px'][0]) + ','\n ystr = 'y0=' + '{:.2f}'.format(data_dict['y_px'][0]) + ','\n rstr = 'r=' + '{:.2f}'.format(data_dict['rad'][0]) + ','\n spstr = 'spu=' + '{:d}'.format(is_spurious)\n return nstr + tstr + labstr + xstr + ystr + rstr + spstr\n\ndef save_snapshot(folder_location, img, pix_fmt=\"Mono12\", idx=0):\n rescaling = 1 + (pix_fmt==\"Mono12\")*(4095/255-1)\n img = (img[0].astype(np.int32)/rescaling).astype(np.uint8) # The [0] is some compatibility thing with Bokeh\n pilimg = Image.fromarray(img)\n pilimg.save(folder_location + '\\\\frame_' + '{:06d}'.format(idx) + '.png')\n \ndef init_figure(): \n # Essentially needs the CDS_img and CDS_line objects (from analyse_frame)\n # And myinfo object. Returns Bokeh figure objects\n\n mapper_bw = LinearColorMapper(palette=\"Greys256\")\n mapper_th = LinearColorMapper(palette=['rgba(0,0,0,0)', 'lime'], high=1, low=0)\n\n plotint = figure(title=\"Threshold : orange and pink closer is better\", height=300, width=800, tools=\"\")\n plotint.image(\"img_polar\", x=-np.pi, y=0, dw=2*np.pi, dh=1.4, color_mapper=mapper_bw, global_alpha=1, source=CDS_img)\n plotint.image(\"img_th_polar\", x=-np.pi, y=0, dw=2*np.pi, dh=1.4, color_mapper=mapper_th, global_alpha=0.15, source=CDS_img)\n plotint.line(x='theta', y='r_fourier', line_color='hotpink', line_width=2, line_dash='dashed', source=CDS_line)\n plotint.line(x='theta', y='r_gradient', line_color='orange', line_width=2, line_dash='dotted', source=CDS_line)\n plotint.y_range.start, plotint.y_range.end = 0.85, 1.15\n plotint.x_range.start, plotint.x_range.end = -np.pi, np.pi\n plotint.xaxis.axis_label, plotint.yaxis.axis_label = 'θ', 'r/R'\n\n f_height, f_width = np.shape(CDS_img.data['img'][0]) # Affected by img_padding (used in analyse_frame) \n hist_max = np.max(CDS_line.data['lum_hist'])\n\n plotimg = figure(height=400, width=400, title='Raw Reference Frame', tools=\"\", match_aspect=True)\n plotpdf = figure(height=400, width=400, title='Histogram', tools=\"\")\n plotimg.image(\"img\", dw=f_width, dh=f_height, x=0, y=0, color_mapper=mapper_bw, source=CDS_img)\n # plotimg.image(\"img_th\", dw=f_width, dh=f_height, x=0, y=0, color_mapper=mapper_th, global_alpha=0.25, source=CDS_img)\n plotimg.cross(x=\"x_px\", y=\"y_px\", size=10, line_color='lime', source=CDS_img)\n plotpdf.line([myinfo['threshold'],myinfo['threshold']], [0, hist_max], line_dash='dashed')\n plotpdf.line(x=\"lum_bins\", y='lum_hist', source=CDS_line)\n\n return plotint, plotimg, plotpdf\n\n##### SAY HI TO THE CAMERA and set some parameters\ndef init_camera(myinfo):\n camera = pylon.InstantCamera(pylon.TlFactory.GetInstance().CreateFirstDevice())\n camera.Close()\n camera.Open()\n myinfo['cameraname'] = camera.GetDeviceInfo().GetModelName()\n camera.AcquisitionFrameRateEnable.SetValue(True), camera.AcquisitionFrameRateAbs.SetValue(5) # Setting fps to 5\n camera.BinningModeVertical.SetValue('Averaging'), camera.BinningModeHorizontal.SetValue('Averaging') # Activating binning in x & y\n camera.BinningHorizontal.SetValue(2), camera.BinningVertical.SetValue(2) # Using 2^1 (3 would be 2^2 I guess) binning \n camera.Width.SetValue(imagesize[0]), camera.Height.SetValue(imagesize[1]) \n camera.CenterX.SetValue(True), camera.CenterY.SetValue(True)\n camera.ExposureTimeAbs.SetValue(myinfo['exposure'])\n camera.PixelFormat.SetValue(myinfo['pixel_format'])\n camera.GevTimestampControlReset()\n return camera\n\n# # Emulate with a PNG file \n# img = Image.open('C:\\\\Users\\\\saint-michel\\\\Documents\\\\Python\\\\Bubbles_20211109\\\\frame_00000.png')\n# img = np.array(img)\n# time_ref = 0\n# pixel_format='Mono8'\n# cameraname = 'None'\n\n# Preparing acquisition information for later \nglobal_time_ref = time.gmtime()\ngt_str = time.strftime('%Y/%m/%d %H:%M:%S', global_time_ref)\npixsize = 1000/zoom/90.4 # in UM per PX\nmyinfo = {'time_ref': gt_str, 'zoom': zoom, 'pixsize': pixsize, 'pixel_format': pixel_format,\n 'threshold': threshold, 'width':imagesize[1], 'height':imagesize[0], 'smoothing':filter_size, 'exposure':exposure,\n 'pixel_fmt': pixel_format}\nif myinfo[\"pixel_format\"] == 'Mono12':\n myinfo['max_lum'] = 4095\nelse: \n myinfo['max_lum'] = 255\nmycolumns = ['frame', 'time', 'label', 'x', 'y', 'radius', 'eccentricity', 'spurious']\nmyunits = ['1', 's', '1', 'um', 'um', 'um', '1', '1']\nmyfmt = '%05d,%07.1f,%1d,%03.2f,%03.2f,%03.2f,%1.2f,%1d'\nidx = 0\n\n# Analysing image\ncamera = init_camera(myinfo)\nrawframe = camera.GrabOne(5000)\ncamera.Close()\n\nmyinfo['reftime'] = rawframe.TimeStamp\nref_imgdata, ref_linedata = analyse_frame(rawframe.Array, myinfo, time=rawframe.TimeStamp)\ndata_array = format_data(ref_imgdata, myinfo)\nlog_str = format_logstr(ref_imgdata)\nCDS_img, CDS_line = ColumnDataSource(data=ref_imgdata), ColumnDataSource(data=ref_linedata)\n\n#### DISPLAYING / LOGGING INFO \nos.makedirs(folder_location, exist_ok=True)\nlog_file = codecs.open(folder_location + \"\\\\log.txt\", mode='w', encoding=\"utf-8\")\ndata_file = codecs.open(folder_location + \"\\\\data.csv\", mode='w', encoding=\"utf-8\")\nwrite_logheader(log_file, myinfo)\nwrite_csvheader(data_file, myunits)\nwrite_csvheader(data_file, mycolumns)\nnp.savetxt(data_file, data_array, fmt=myfmt, delimiter=',')\nlog_file.write(log_str + '\\n')\nsave_snapshot(folder_location, ref_imgdata['img'])\nlog_file.close()\ndata_file.close()\n\n#### PLOTTING RESULTS #########\noutput_notebook()\nplotint, plotimg, plotpdf = init_figure()\nBokehModel(column(row(plotimg, plotpdf), plotint))", "> local_minimum : Found two maxima at : [101 327] / minimum around : 214\ntime_ref:2021/12/16 11:42:58\nzoom:3\npixsize:3.6873156342182885\npixel_format:Mono12\nthreshold:2434.3444444444444\nwidth:512\nheight:512\nsmoothing:10\nexposure:100\npixel_fmt:Mono12\nmax_lum:4095\ncameraname:acA1300-60gm\nreftime:228432030\npadsize:16\n" ] ], [ [ "## Step 2 : FRAME GRABBING LOOP \n\nSome bits have been initialised in Step 1, so please run it at least once\n\n* Spurious image detection with `spurious` or `spu`\n* Provide time stamps for each image\n* Can be restarted if stopped\n* Handles events (bubble disappearing, appearing, moving, ...)\n* Try an extra `camera.Close()` if you interrupted the program", "_____no_output_____" ] ], [ [ "import traceback\nfrom IPython.display import clear_output\n\n############# (Bad) event management routine #########################\"\"\n\ndef bubble_event(now_data, ref_data):\n event_str = ''\n nbubble_change = np.size(now_data['label']) != np.size(ref_data['label'])\n chunk_timeout = now_data['frame'][0] - ref_data['frame'][0] > chunk_size\n xy_change, r_change = False, False\n\n if not nbubble_change: \n \n r_change = np.abs(now_data['rad'] - ref_data['rad'])\n x_change = np.abs(now_data['x_px'] - ref_data['x_px'])\n y_change = np.abs(now_data['y_px'] - ref_data['y_px'])\n\n r_change = any(r_change > 1)\n xy_change = any(x_change > 3) or any(y_change > 3)\n\n if r_change:\n event_str = ' | Event ! One (or more) bubbles have changed radius ... Refreshing & Saving'\n if xy_change:\n event_str = ' | Event ! One (or more) bubbles have changed location ... Refreshing & Saving'\n if chunk_timeout:\n event_str = ' | Event ! There has been : ' + str(chunk_size) + ' frames with no event ... Refreshing & Saving'\n if nbubble_change:\n event_str = ' | Event ! One (or several) bubbles have appeared or disappeared ... Refreshing & Saving'\n \n any_change = xy_change or r_change or nbubble_change or chunk_timeout\n\n return any_change, event_str\n\n########################## MAIN SEQUENCE #####################################\n\ncamera.Open()\n\nif not camera.IsGrabbing():\n camera.StartGrabbing(pylon.GrabStrategy_LatestImageOnly)\n\ntry:\n while True:\n data_file = open(folder_location + '\\\\data.csv', 'a', encoding='utf-8')\n log_file = open(folder_location + '\\\\log.txt', 'a', encoding='utf-8')\n grab = camera.RetrieveResult(5000, pylon.TimeoutHandling_ThrowException) # I don't really mind if image comes late, I just want to know when it arrives\n\n if grab.GrabSucceeded(): # We could fail for any other reason \n idx += 1\n now_imgdata, now_linedata = analyse_frame(grab.Array, myinfo, grab.TimeStamp)\n data_array = np.append(data_array, format_data(now_imgdata, myinfo), axis=0)\n grab.Release()\n is_event, event_str = bubble_event(now_imgdata, ref_imgdata)\n log_str = format_logstr(now_imgdata)\n print(log_str + event_str)\n\n if is_event:\n np.savetxt(data_file, data_array, fmt=myfmt, delimiter=',')\n data_file.flush()\n save_snapshot(folder_location, now_imgdata['img'], pix_fmt=\"Mono12\", idx=idx)\n data_array = np.zeros((0,8))\n ref_imgdata = now_imgdata\n CDS_img.data = now_imgdata\n CDS_line.data = now_linedata\n log_file.write(log_str + event_str + '\\n')\n\n # Clear display from time to time\n if np.mod(idx,10) == 0:\n clear_output() \n\n time.sleep(1)\n\n################################################################################################\n## HANDLING ERRORS SECTION HERE ... #############################################################\n#################################################################################################\nexcept pylon.TimeoutException:\n timeout_str = ' /!\\\\ Timeout ... ! '\n log_file.write(log_str + timeout_str + '\\n')\n print(timeout_str)\n pass\n\nexcept SystemError as e:\n ## I KNOW IT IS SUPER UGLY, HATE ME ALL YOU WANT\n if \"KeyboardInterrupt\" in traceback.format_exc():\n interrupt_str = ' /!\\\\ Keyboard Interrupted ... ! '\n log_file.write(log_str + interrupt_str + '\\n')\n print(interrupt_str)\n grab.Release()\n camera.StopGrabbing()\n camera.Close()\n data_file.close()\n log_file.close()\n else:\n err_str = 'N°' + str(idx) + e\n log_file.write(err_str)\n print(err_str)\n pass\n\nexcept KeyboardInterrupt:\n interrupt_str = ' /!\\\\ Keyboard Interrupted ... ! '\n log_file.write(log_str + interrupt_str + '\\n')\n print(interrupt_str)\n grab.Release()\n camera.StopGrabbing()\n camera.Close() \n data_file.close()\n log_file.close()", "Frame=089611,t=108301.80,n=1,x0=18.83,y0=125.36,r=5.78,spu=0\nFrame=089612,t=108303.00,n=1,x0=18.83,y0=125.36,r=5.78,spu=0\nFrame=089613,t=108304.20,n=1,x0=18.83,y0=125.36,r=5.78,spu=0\nFrame=089614,t=108305.40,n=1,x0=18.93,y0=125.27,r=5.81,spu=0\nFrame=089615,t=108306.60,n=1,x0=18.83,y0=125.36,r=5.78,spu=0\nFrame=089616,t=108308.00,n=1,x0=18.93,y0=125.27,r=5.81,spu=0\nFrame=089617,t=108309.20,n=1,x0=18.83,y0=125.36,r=5.78,spu=0\nFrame=089618,t=108310.40,n=1,x0=18.74,y0=125.29,r=5.73,spu=0\n" ], [ "import skimage.filters as skfi\nfrom skimage.data import astronaut\nfrom bokeh.plotting import figure, show, row\nfrom bokeh.models import LinearColorMapper\nfrom bokeh.palettes import Greys256\nimport numpy as np\n\n\nast = astronaut()[:,:,0]/255\nheight, width = np.shape(ast)\nastf = skfi.gaussian(ast, sigma=1)\ncmapper = LinearColorMapper(palette=Greys256, low=0, high=1)\nf1 = figure(width=300, height=300, match_aspect=True)\nf2 = figure(width=300, height=300, match_aspect=True)\nf1.image([ast], x=0, y=0, dw=height, dh=width, color_mapper=cmapper)\nf2.image([astf], x=0, y=0, dw=height, dh=width, color_mapper=cmapper)\nshow(row(f1,f2))\n", "_____no_output_____" ], [ "ast", "_____no_output_____" ] ] ]

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

[ [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "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 random\nimport numpy as np\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:13][0] = -np.arange(3, 15)[::-1]\nV_opt[0:13][1] = -np.arange(3, 15)[::-1] + 1\nV_opt[0:13][2] = -np.arange(3, 15)[::-1] + 2\nV_opt[3][0] = -13\n\nplot_values(V_opt)", "/Users/amrmkayid/anaconda3/envs/kayddrl/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:424: MatplotlibDeprecationWarning: \nPassing one of 'on', 'true', 'off', 'false' as a boolean is deprecated; use an actual boolean (True/False) instead.\n warn_deprecated(\"2.2\", \"Passing one of 'on', 'true', 'off', 'false' as a \"\n/Users/amrmkayid/anaconda3/envs/kayddrl/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:424: MatplotlibDeprecationWarning: \nPassing one of 'on', 'true', 'off', 'false' as a boolean is deprecated; use an actual boolean (True/False) instead.\n warn_deprecated(\"2.2\", \"Passing one of 'on', 'true', 'off', 'false' as a \"\n/Users/amrmkayid/anaconda3/envs/kayddrl/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:424: MatplotlibDeprecationWarning: \nPassing one of 'on', 'true', 'off', 'false' as a boolean is deprecated; use an actual boolean (True/False) instead.\n warn_deprecated(\"2.2\", \"Passing one of 'on', 'true', 'off', 'false' as a \"\n/Users/amrmkayid/anaconda3/envs/kayddrl/lib/python3.7/site-packages/matplotlib/cbook/__init__.py:424: MatplotlibDeprecationWarning: \nPassing one of 'on', 'true', 'off', 'false' as a boolean is deprecated; use an actual boolean (True/False) instead.\n warn_deprecated(\"2.2\", \"Passing one of 'on', 'true', 'off', 'false' as a \"\n" ] ], [ [ "### 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 current = Q[state][action]\n Qsa_next = Q[next_state][next_action] if next_state is not None else 0 \n \n target = reward + (gamma * Qsa_next) \n new_value = current + (alpha * (target - current))\n\n return new_value", "_____no_output_____" ], [ "def epsilon_greedy(Q, state, nA, eps):\n \n if random.random() > eps:\n return np.argmax(Q[state])\n else:\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\n Q = defaultdict(lambda: np.zeros(env.nA))\n\n # initialize performance monitor\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 # loop over episodes\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 ## TODO: complete the function\n score = 0\n state = env.reset()\n \n eps = 1.0 / i_episode\n action = epsilon_greedy(Q, state, nA, eps)\n \n while True:\n next_state, reward, done, info = env.step(action)\n score += reward\n \n if not done:\n next_action = epsilon_greedy(Q, next_state, nA, eps)\n Q[state][action] = update_Q_sarsa(alpha, gamma, Q, \\\n state, action, reward, next_state, next_action)\n \n state = next_state\n action = next_action\n\n if done:\n Q[state][action] = update_Q_sarsa(alpha, gamma, Q, \\\n state, action, reward)\n\n tmp_scores.append(score)\n break\n \n if (i_episode % plot_every == 0):\n avg_scores.append(np.mean(tmp_scores))\n \n \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 \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, 5000, .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 5000/5000" ] ], [ [ "### 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_learning(alpha, gamma, Q, state, action, reward, next_state=None):\n current = Q[state][action]\n Qsa_next = np.max(Q[next_state]) if next_state is not None else 0 \n \n target = reward + (gamma * Qsa_next)\n new_value = current + (alpha * (target - current))\n return new_value", "_____no_output_____" ], [ "def q_learning(env, num_episodes, alpha, gamma=1.0, plot_every=100):\n nA = env.action_space.n\n Q = defaultdict(lambda: np.zeros(env.nA))\n\n # initialize performance monitor\n tmp_scores = deque(maxlen=plot_every)\n avg_scores = deque(maxlen=num_episodes)\n \n # loop over episodes\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 ## TODO: complete the function\n score = 0\n state = env.reset()\n \n eps = 1.0 / i_episode\n action = epsilon_greedy(Q, state, nA, eps)\n \n while True:\n next_state, reward, done, info = env.step(action)\n score += reward\n \n if not done:\n next_action = epsilon_greedy(Q, next_state, nA, eps)\n Q[state][action] = update_Q_learning(alpha, gamma, Q, \\\n state, action, reward, next_state)\n \n state = next_state\n\n if done:\n tmp_scores.append(score)\n break\n \n if (i_episode % plot_every == 0):\n avg_scores.append(np.mean(tmp_scores))\n \n \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 \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_expected_sarsa(alpha, gamma, nA, eps, Q, state, action, reward, next_state=None):\n current = Q[state][action] \n policy_s = np.ones(nA) * eps / nA \n policy_s[np.argmax(Q[next_state])] = 1 - eps + (eps / nA)\n Qsa_next = np.dot(Q[next_state], policy_s) \n target = reward + (gamma * Qsa_next) \n new_value = current + (alpha * (target - current))\n return new_value", "_____no_output_____" ], [ "def expected_sarsa(env, num_episodes, alpha, gamma=1.0, plot_every=100):\n nA = env.action_space.n\n Q = defaultdict(lambda: np.zeros(env.nA))\n\n # initialize performance monitor\n tmp_scores = deque(maxlen=plot_every)\n avg_scores = deque(maxlen=num_episodes)\n \n # loop over episodes\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 ## TODO: complete the function\n score = 0\n state = env.reset()\n eps = 0.005\n \n while True:\n action = epsilon_greedy(Q, state, nA, eps)\n next_state, reward, done, info = env.step(action)\n score += reward\n\n Q[state][action] = update_Q_expected_sarsa(alpha, gamma, nA, eps, Q, \\\n state, action, reward, next_state)\n\n state = next_state\n\n if done:\n tmp_scores.append(score)\n break\n \n if (i_episode % plot_every == 0):\n avg_scores.append(np.mean(tmp_scores))\n \n \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 \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, 10000, 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 10000/10000" ] ] ]

[ "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" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "Hw 18_11_2021", "_____no_output_____" ] ], [ [ "# Проверка целостности матрицы, т.е. количество элементов в строках\n# должны совпадать, тип матрицы должен быть список\ndef CheckMatrixCompletness(matrix):\n # проверяем тип всей матрицы\n if type(matrix) is not list:\n return False\n if type(matrix[0]) is not list:\n return False\n # определим количество столбцов\n column_num = len(matrix[0])\n # проверяем целостность всех строк\n for row in matrix:\n if type(row) is not list:\n return False\n if len(row) != column_num:\n return False\n # Проверка, что все элементы матрицы - числа\n for element in row:\n if type(element) is not int and type(element) is not float:\n return False\n return True", "_____no_output_____" ], [ "def AddVectors(vector_a, vector_b):\n if len(vector_a) != len(vector_b):\n return \"Vector lengths aren't equal!\"\n sum_vector = []\n for i in range(len(vector_a)):\n sum_vector.append(vector_a[i] + vector_b[i])\n return sum_vector", "_____no_output_____" ], [ "def MultiplyToScalar(vector, scalar):\n res_vector = []\n for elem in vector:\n res_vector.append(scalar * elem)\n return res_vector", "_____no_output_____" ], [ "def GetColumn(matrix, column):\n result = []\n \n for i in range(0, len(matrix)):\n result += [matrix[i][column]]\n return result", "_____no_output_____" ], [ "def TranspouseMatrix(matrix):\n if not CheckMatrixCompletness(matrix):\n return \"Matrix is incorrect\"\n result = []\n for i in range(len(matrix[0])):\n result += [[]]\n for j in range(len(matrix)):\n result[i] += [matrix[j][i]]\n return result", "_____no_output_____" ], [ "'''\n [1 2] [1 2 3] = [9 12 15]\n [3 4] [4 5 6] = [19 26 33]\n \n 1 * [1 3]' + 4 * [2 4]' = [1 3]' + [8 16]' = [9 19]'\n 2 * [1 3]' + 5 * [2 4]' = [2 6]' + [10 20]' = [12 26]'\n 3 * [1 3]' + 6 * [2 4]' = [3 9]' + [12 24]' = [15 33]'\n'''\ndef MatrixMultiplation(matrix_a, matrix_b):\n # Проверка соответствия на размеров матриц на произведение\n matrix_a_shape = CalculateMatrixShape(matrix_a)\n matrix_b_shape = CalculateMatrixShape(matrix_b)\n \n if type(matrix_a_shape) is str:\n return \"Matrix_a is incorrect\"\n if type(matrix_b_shape) is str:\n return \"Matrix_b is incorrect\"\n if matrix_a_shape[1] != matrix_b_shape[0]:\n return \"Matrices shapes are not insufficient.\"\n # --------------------------------------------------------\n \n #return \"Ok\"\n \n result = []\n \n for matrix_b_column_id in range(0, len(matrix_b[0])):\n #print(GetColumn(matrix_b, matrix_b_column_id))\n matrix_b_column = GetColumn(matrix_b, matrix_b_column_id)\n vec_res = [0] * len(matrix_a)\n for matrix_a_column_id in range(0, len(matrix_a[0])):\n vec = MultiplyToScalar(GetColumn(matrix_a, matrix_a_column_id), matrix_b_column[matrix_a_column_id])\n vec_res = AddVectors(vec_res, vec)\n #print(\"--\", GetColumn(matrix_a, matrix_a_column_id), \"--\", matrix_b_column[matrix_a_column_id], \"--\", vec)\n #print (\"!!!\", vec_res)\n result += [vec_res]\n return TranspouseMatrix(result)", "_____no_output_____" ], [ "# Вычисление размеров матрицы\ndef CalculateMatrixShape(matrix):\n if not CheckMatrixCompletness(matrix):\n return \"Matrix is incorrect\"\n # Количетсво строк\n row_num = len(matrix)\n # Количетсво столбцов\n col_num = len(matrix[0])\n return (row_num, col_num)", "_____no_output_____" ], [ "def MatrixMultiplyToScalar(matrix_a, scalar):\n # Проверка\n matrix_a_shape = CalculateMatrixShape(matrix_a)\n \n if type(matrix_a_shape) is str:\n return \"Matrix_a is incorrect\"\n # --------------------------------------------------------\n \n matrix_a = [] + matrix_a\n for i in range(matrix_a_shape[0]):\n for j in range(matrix_a_shape[1]):\n matrix_a[i][j] *= scalar\n return matrix_a", "_____no_output_____" ], [ "from copy import deepcopy\n\ndef det(arr):\n size_arr = len(arr)\n if size_arr == 1: return arr[0][0]\n result = 0\n for index_x in range(size_arr):\n arr_deepcopy = deepcopy(arr)\n del (arr_deepcopy[0])\n for i in range(len(arr_deepcopy)):\n del (arr_deepcopy[i][index_x])\n result += arr[0][index_x] * (-1 if index_x & 1 else 1 ) * det(arr_deepcopy)\n return result", "_____no_output_____" ], [ "from copy import deepcopy\n\n#Дополнительный Минор \ndef AdditionalMinor(matrix, row, col):\n if not CheckMatrixCompletness(matrix):\n return \"Matrix is incorrect\"\n \n row_num, _ = CalculateMatrixShape(matrix)\n \n matrix = deepcopy(matrix)\n \n del (matrix[row])\n \n for i in range(row_num - 1):\n del (matrix[i][col])\n \n return det(matrix)", "_____no_output_____" ], [ "#Алгебраическое дополнение\ndef AlgebraiComplement(matrix, row, col):\n if not CheckMatrixCompletness(matrix):\n return \"Matrix is incorrect\"\n return (-1)**(row + col) * AdditionalMinor(matrix, row, col)", "_____no_output_____" ], [ "def MatrixInverse(matrix):\n if not CheckMatrixCompletness(matrix):\n return \"Matrix is incorrect\"\n \n matrixDet = det(matrix)\n \n if matrixDet == 0:\n return \"Det = 0\"\n \n row_num, col_num = CalculateMatrixShape(matrix)\n\n result = []\n \n for i in range(row_num):\n result += [[]]\n for j in range(col_num):\n result[i] += [AlgebraiComplement(matrix, j, i)]\n \n \n\n return MatrixMultiplyToScalar(result, 1 / matrixDet)", "_____no_output_____" ], [ "a = [[-1, 2, -2],\n [2, -1, 5],\n [3, -2, 4]]\n\nprint (MatrixInverse(a))", "[[0.6000000000000001, -0.4, 0.8], [0.7000000000000001, 0.2, 0.1], [-0.1, 0.4, -0.30000000000000004]]\n" ] ] ]

[ "markdown", "code" ]

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Transfer Learning\n\nMost of the time you won't want to train a whole convolutional network yourself. Modern ConvNets training on huge datasets like ImageNet take weeks on multiple GPUs. Instead, most people use a pretrained network either as a fixed feature extractor, or as an initial network to fine tune. In this notebook, you'll be using [VGGNet](https://arxiv.org/pdf/1409.1556.pdf) trained on the [ImageNet dataset](http://www.image-net.org/) as a feature extractor. Below is a diagram of the VGGNet architecture.\n\n<img src=\"assets/cnnarchitecture.jpg\" width=700px>\n\nVGGNet is great because it's simple and has great performance, coming in second in the ImageNet competition. The idea here is that we keep all the convolutional layers, but replace the final fully connected layers with our own classifier. This way we can use VGGNet as a feature extractor for our images then easily train a simple classifier on top of that. What we'll do is take the first fully connected layer with 4096 units, including thresholding with ReLUs. We can use those values as a code for each image, then build a classifier on top of those codes.\n\nYou can read more about transfer learning from [the CS231n course notes](http://cs231n.github.io/transfer-learning/#tf).\n\n## Pretrained VGGNet\n\nWe'll be using a pretrained network from https://github.com/machrisaa/tensorflow-vgg. This code is already included in 'tensorflow_vgg' directory, sdo you don't have to clone it.\n\nThis is a really nice implementation of VGGNet, quite easy to work with. The network has already been trained and the parameters are available from this link. **You'll need to clone the repo into the folder containing this notebook.** Then download the parameter file using the next cell.", "_____no_output_____" ] ], [ [ "from urllib.request import urlretrieve\nfrom os.path import isfile, isdir\nfrom tqdm import tqdm\n\nvgg_dir = 'tensorflow_vgg/'\n# Make sure vgg exists\nif not isdir(vgg_dir):\n raise Exception(\"VGG directory doesn't exist!\")\n\nclass DLProgress(tqdm):\n last_block = 0\n\n def hook(self, block_num=1, block_size=1, total_size=None):\n self.total = total_size\n self.update((block_num - self.last_block) * block_size)\n self.last_block = block_num\n\nif not isfile(vgg_dir + \"vgg16.npy\"):\n with DLProgress(unit='B', unit_scale=True, miniters=1, desc='VGG16 Parameters') as pbar:\n urlretrieve(\n 'https://s3.amazonaws.com/content.udacity-data.com/nd101/vgg16.npy',\n vgg_dir + 'vgg16.npy',\n pbar.hook)\nelse:\n print(\"Parameter file already exists!\")", "VGG16 Parameters: 553MB [00:31, 17.6MB/s] \n" ] ], [ [ "## Flower power\n\nHere we'll be using VGGNet to classify images of flowers. To get the flower dataset, run the cell below. This dataset comes from the [TensorFlow inception tutorial](https://www.tensorflow.org/tutorials/image_retraining).", "_____no_output_____" ] ], [ [ "import tarfile\n\ndataset_folder_path = 'flower_photos'\n\nclass DLProgress(tqdm):\n last_block = 0\n\n def hook(self, block_num=1, block_size=1, total_size=None):\n self.total = total_size\n self.update((block_num - self.last_block) * block_size)\n self.last_block = block_num\n\nif not isfile('flower_photos.tar.gz'):\n with DLProgress(unit='B', unit_scale=True, miniters=1, desc='Flowers Dataset') as pbar:\n urlretrieve(\n 'http://download.tensorflow.org/example_images/flower_photos.tgz',\n 'flower_photos.tar.gz',\n pbar.hook)\n\nif not isdir(dataset_folder_path):\n with tarfile.open('flower_photos.tar.gz') as tar:\n tar.extractall()\n tar.close()", "Flowers Dataset: 229MB [00:02, 83.5MB/s] \n" ] ], [ [ "## ConvNet Codes\n\nBelow, we'll run through all the images in our dataset and get codes for each of them. That is, we'll run the images through the VGGNet convolutional layers and record the values of the first fully connected layer. We can then write these to a file for later when we build our own classifier.\n\nHere we're using the `vgg16` module from `tensorflow_vgg`. The network takes images of size $224 \\times 224 \\times 3$ as input. Then it has 5 sets of convolutional layers. The network implemented here has this structure (copied from [the source code](https://github.com/machrisaa/tensorflow-vgg/blob/master/vgg16.py)):\n\n```\nself.conv1_1 = self.conv_layer(bgr, \"conv1_1\")\nself.conv1_2 = self.conv_layer(self.conv1_1, \"conv1_2\")\nself.pool1 = self.max_pool(self.conv1_2, 'pool1')\n\nself.conv2_1 = self.conv_layer(self.pool1, \"conv2_1\")\nself.conv2_2 = self.conv_layer(self.conv2_1, \"conv2_2\")\nself.pool2 = self.max_pool(self.conv2_2, 'pool2')\n\nself.conv3_1 = self.conv_layer(self.pool2, \"conv3_1\")\nself.conv3_2 = self.conv_layer(self.conv3_1, \"conv3_2\")\nself.conv3_3 = self.conv_layer(self.conv3_2, \"conv3_3\")\nself.pool3 = self.max_pool(self.conv3_3, 'pool3')\n\nself.conv4_1 = self.conv_layer(self.pool3, \"conv4_1\")\nself.conv4_2 = self.conv_layer(self.conv4_1, \"conv4_2\")\nself.conv4_3 = self.conv_layer(self.conv4_2, \"conv4_3\")\nself.pool4 = self.max_pool(self.conv4_3, 'pool4')\n\nself.conv5_1 = self.conv_layer(self.pool4, \"conv5_1\")\nself.conv5_2 = self.conv_layer(self.conv5_1, \"conv5_2\")\nself.conv5_3 = self.conv_layer(self.conv5_2, \"conv5_3\")\nself.pool5 = self.max_pool(self.conv5_3, 'pool5')\n\nself.fc6 = self.fc_layer(self.pool5, \"fc6\")\nself.relu6 = tf.nn.relu(self.fc6)\n```\n\nSo what we want are the values of the first fully connected layer, after being ReLUd (`self.relu6`). To build the network, we use\n\n```\nwith tf.Session() as sess:\n vgg = vgg16.Vgg16()\n input_ = tf.placeholder(tf.float32, [None, 224, 224, 3])\n with tf.name_scope(\"content_vgg\"):\n vgg.build(input_)\n```\n\nThis creates the `vgg` object, then builds the graph with `vgg.build(input_)`. Then to get the values from the layer,\n\n```\nfeed_dict = {input_: images}\ncodes = sess.run(vgg.relu6, feed_dict=feed_dict)\n```", "_____no_output_____" ] ], [ [ "import os\n\nimport numpy as np\nimport tensorflow as tf\n\nfrom tensorflow_vgg import vgg16\nfrom tensorflow_vgg import utils", "_____no_output_____" ], [ "data_dir = 'flower_photos/'\ncontents = os.listdir(data_dir)\nclasses = [each for each in contents if os.path.isdir(data_dir + each)]", "_____no_output_____" ] ], [ [ "Below I'm running images through the VGG network in batches.\n\n> **Exercise:** Below, build the VGG network. Also get the codes from the first fully connected layer (make sure you get the ReLUd values).", "_____no_output_____" ] ], [ [ "# Set the batch size higher if you can fit in in your GPU memory\nbatch_size = 10\ncodes_list = []\nlabels = []\nbatch = []\n\ncodes = None\n\nwith tf.Session() as sess:\n \n # TODO: Build the vgg network here\n vgg = vgg16.Vgg16()\n input_ = tf.placeholder(tf.float32, [None, 224, 224, 3])\n with tf.name_scope(\"content_vgg\"):\n vgg.build(input_)\n\n for each in classes:\n print(\"Starting {} images\".format(each))\n class_path = data_dir + each\n files = os.listdir(class_path)\n for ii, file in enumerate(files, 1):\n # Add images to the current batch\n # utils.load_image crops the input images for us, from the center\n img = utils.load_image(os.path.join(class_path, file))\n batch.append(img.reshape((1, 224, 224, 3)))\n labels.append(each)\n \n # Running the batch through the network to get the codes\n if ii % batch_size == 0 or ii == len(files):\n \n # Image batch to pass to VGG network\n images = np.concatenate(batch)\n \n # TODO: Get the values from the relu6 layer of the VGG network \n codes_batch = sess.run(vgg.relu6, feed_dict={input_: images})\n \n # Here I'm building an array of the codes\n if codes is None:\n codes = codes_batch\n else:\n codes = np.concatenate((codes, codes_batch))\n \n # Reset to start building the next batch\n batch = []\n print('{} images processed'.format(ii))", "/home/ubuntu/deep-learning/transfer-learning/tensorflow_vgg/vgg16.npy\nnpy file loaded\nbuild model started\nbuild model finished: 0s\nStarting roses images\n10 images processed\n20 images processed\n30 images processed\n40 images processed\n50 images processed\n60 images processed\n70 images processed\n80 images processed\n90 images processed\n100 images processed\n110 images processed\n120 images processed\n130 images processed\n140 images processed\n150 images processed\n160 images processed\n170 images processed\n180 images processed\n190 images processed\n200 images processed\n210 images processed\n220 images processed\n230 images processed\n240 images processed\n250 images processed\n260 images processed\n270 images processed\n280 images processed\n290 images processed\n300 images processed\n310 images processed\n320 images processed\n330 images processed\n340 images processed\n350 images processed\n360 images processed\n370 images processed\n380 images processed\n390 images processed\n400 images processed\n410 images processed\n420 images processed\n430 images processed\n440 images processed\n450 images processed\n460 images processed\n470 images processed\n480 images processed\n490 images processed\n500 images processed\n510 images processed\n520 images processed\n530 images processed\n540 images processed\n550 images processed\n560 images processed\n570 images processed\n580 images processed\n590 images processed\n600 images processed\n610 images processed\n620 images processed\n630 images processed\n640 images processed\n641 images processed\nStarting daisy images\n10 images processed\n20 images processed\n30 images processed\n40 images processed\n50 images processed\n60 images processed\n70 images processed\n80 images processed\n90 images processed\n100 images processed\n110 images processed\n120 images processed\n130 images processed\n140 images processed\n150 images processed\n160 images processed\n170 images processed\n180 images processed\n190 images processed\n200 images processed\n210 images processed\n220 images processed\n230 images processed\n240 images processed\n250 images processed\n260 images processed\n270 images processed\n280 images processed\n290 images processed\n300 images processed\n310 images processed\n320 images processed\n330 images processed\n340 images processed\n350 images processed\n360 images processed\n370 images processed\n380 images processed\n390 images processed\n400 images processed\n410 images processed\n420 images processed\n430 images processed\n440 images processed\n450 images processed\n460 images processed\n470 images processed\n480 images processed\n490 images processed\n500 images processed\n510 images processed\n520 images processed\n530 images processed\n540 images processed\n550 images processed\n560 images processed\n570 images processed\n580 images processed\n590 images processed\n600 images processed\n610 images processed\n620 images processed\n630 images processed\n633 images processed\nStarting tulips images\n10 images processed\n20 images processed\n30 images processed\n40 images processed\n50 images processed\n60 images processed\n70 images processed\n80 images processed\n90 images processed\n100 images processed\n110 images processed\n120 images processed\n130 images processed\n140 images processed\n150 images processed\n160 images processed\n170 images processed\n180 images processed\n190 images processed\n200 images processed\n210 images processed\n220 images processed\n230 images processed\n240 images processed\n250 images processed\n260 images processed\n270 images processed\n280 images processed\n290 images processed\n300 images processed\n310 images processed\n320 images processed\n330 images processed\n340 images processed\n350 images processed\n360 images processed\n370 images processed\n380 images processed\n390 images processed\n400 images processed\n410 images processed\n420 images processed\n430 images processed\n440 images processed\n450 images processed\n460 images processed\n470 images processed\n480 images processed\n490 images processed\n500 images processed\n510 images processed\n520 images processed\n530 images processed\n540 images processed\n550 images processed\n560 images processed\n570 images processed\n580 images processed\n590 images processed\n600 images processed\n610 images processed\n620 images processed\n630 images processed\n640 images processed\n650 images processed\n660 images processed\n670 images processed\n680 images processed\n690 images processed\n700 images processed\n710 images processed\n720 images processed\n730 images processed\n740 images processed\n750 images processed\n760 images processed\n770 images processed\n780 images processed\n790 images processed\n799 images processed\nStarting sunflowers images\n10 images processed\n20 images processed\n30 images processed\n40 images processed\n50 images processed\n60 images processed\n70 images processed\n80 images processed\n90 images processed\n100 images processed\n110 images processed\n120 images processed\n130 images processed\n140 images processed\n150 images processed\n160 images processed\n170 images processed\n180 images processed\n190 images processed\n200 images processed\n210 images processed\n220 images processed\n230 images processed\n240 images processed\n250 images processed\n260 images processed\n270 images processed\n280 images processed\n290 images processed\n300 images processed\n310 images processed\n320 images processed\n330 images processed\n340 images processed\n350 images processed\n360 images processed\n370 images processed\n380 images processed\n390 images processed\n400 images processed\n410 images processed\n420 images processed\n430 images processed\n440 images processed\n450 images processed\n460 images processed\n470 images processed\n480 images processed\n490 images processed\n500 images processed\n510 images processed\n520 images processed\n530 images processed\n540 images processed\n550 images processed\n560 images processed\n570 images processed\n580 images processed\n590 images processed\n600 images processed\n610 images processed\n620 images processed\n630 images processed\n640 images processed\n650 images processed\n660 images processed\n670 images processed\n680 images processed\n690 images processed\n699 images processed\nStarting dandelion images\n10 images processed\n20 images processed\n30 images processed\n40 images processed\n50 images processed\n60 images processed\n70 images processed\n80 images processed\n90 images processed\n100 images processed\n110 images processed\n120 images processed\n130 images processed\n140 images processed\n150 images processed\n160 images processed\n170 images processed\n180 images processed\n190 images processed\n200 images processed\n210 images processed\n220 images processed\n230 images processed\n240 images processed\n250 images processed\n260 images processed\n270 images processed\n280 images processed\n290 images processed\n300 images processed\n310 images processed\n320 images processed\n330 images processed\n340 images processed\n350 images processed\n360 images processed\n370 images processed\n380 images processed\n390 images processed\n400 images processed\n410 images processed\n420 images processed\n430 images processed\n440 images processed\n450 images processed\n460 images processed\n470 images processed\n480 images processed\n490 images processed\n500 images processed\n510 images processed\n520 images processed\n530 images processed\n540 images processed\n550 images processed\n560 images processed\n570 images processed\n580 images processed\n590 images processed\n600 images processed\n610 images processed\n620 images processed\n630 images processed\n640 images processed\n650 images processed\n660 images processed\n670 images processed\n680 images processed\n690 images processed\n700 images processed\n710 images processed\n720 images processed\n730 images processed\n740 images processed\n750 images processed\n760 images processed\n770 images processed\n780 images processed\n790 images processed\n800 images processed\n810 images processed\n820 images processed\n830 images processed\n840 images processed\n850 images processed\n860 images processed\n870 images processed\n880 images processed\n890 images processed\n898 images processed\n" ], [ "# write codes to file\nwith open('codes', 'w') as f:\n codes.tofile(f)\n \n# write labels to file\nimport csv\nwith open('labels', 'w') as f:\n writer = csv.writer(f, delimiter='\\n')\n writer.writerow(labels)", "_____no_output_____" ] ], [ [ "## Building the Classifier\n\nNow that we have codes for all the images, we can build a simple classifier on top of them. The codes behave just like normal input into a simple neural network. Below I'm going to have you do most of the work.", "_____no_output_____" ] ], [ [ "# read codes and labels from file\nimport csv\n\nwith open('labels') as f:\n reader = csv.reader(f, delimiter='\\n')\n labels = np.array([each for each in reader if len(each) > 0]).squeeze()\nwith open('codes') as f:\n codes = np.fromfile(f, dtype=np.float32)\n codes = codes.reshape((len(labels), -1))", "_____no_output_____" ] ], [ [ "### Data prep\n\nAs usual, now we need to one-hot encode our labels and create validation/test sets. First up, creating our labels!\n\n> **Exercise:** From scikit-learn, use [LabelBinarizer](http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.LabelBinarizer.html) to create one-hot encoded vectors from the labels. ", "_____no_output_____" ] ], [ [ "from sklearn import preprocessing\nlb = preprocessing.LabelBinarizer()\nlb.fit(labels)", "_____no_output_____" ], [ "labels_vecs = lb.transform(labels)", "_____no_output_____" ] ], [ [ "Now you'll want to create your training, validation, and test sets. An important thing to note here is that our labels and data aren't randomized yet. We'll want to shuffle our data so the validation and test sets contain data from all classes. Otherwise, you could end up with testing sets that are all one class. Typically, you'll also want to make sure that each smaller set has the same the distribution of classes as it is for the whole data set. The easiest way to accomplish both these goals is to use [`StratifiedShuffleSplit`](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.StratifiedShuffleSplit.html) from scikit-learn.\n\nYou can create the splitter like so:\n```\nss = StratifiedShuffleSplit(n_splits=1, test_size=0.2)\n```\nThen split the data with \n```\nsplitter = ss.split(x, y)\n```\n\n`ss.split` returns a generator of indices. You can pass the indices into the arrays to get the split sets. The fact that it's a generator means you either need to iterate over it, or use `next(splitter)` to get the indices. Be sure to read the [documentation](http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.StratifiedShuffleSplit.html) and the [user guide](http://scikit-learn.org/stable/modules/cross_validation.html#random-permutations-cross-validation-a-k-a-shuffle-split).\n\n> **Exercise:** Use StratifiedShuffleSplit to split the codes and labels into training, validation, and test sets.", "_____no_output_____" ] ], [ [ "from sklearn.model_selection import StratifiedShuffleSplit\nss = StratifiedShuffleSplit(n_splits=1, test_size=0.2)\n\ntrain_i, test_i = next(ss.split(codes, labels_vecs))\n\nsplit_val_i = len(test_i)//2\ntest_split, val_split = test_i[:split_val_i], test_i[split_val_i:]\n\ntrain_x, train_y = codes[train_i], labels_vecs[train_i]\nval_x, val_y = codes[val_split], labels_vecs[val_split]\ntest_x, test_y = codes[test_split], labels_vecs[test_split]", "_____no_output_____" ], [ "print(\"Train shapes (x, y):\", train_x.shape, train_y.shape)\nprint(\"Validation shapes (x, y):\", val_x.shape, val_y.shape)\nprint(\"Test shapes (x, y):\", test_x.shape, test_y.shape)", "Train shapes (x, y): (2936, 4096) (2936, 5)\nValidation shapes (x, y): (367, 4096) (367, 5)\nTest shapes (x, y): (367, 4096) (367, 5)\n" ] ], [ [ "If you did it right, you should see these sizes for the training sets:\n\n```\nTrain shapes (x, y): (2936, 4096) (2936, 5)\nValidation shapes (x, y): (367, 4096) (367, 5)\nTest shapes (x, y): (367, 4096) (367, 5)\n```", "_____no_output_____" ], [ "### Classifier layers\n\nOnce you have the convolutional codes, you just need to build a classfier from some fully connected layers. You use the codes as the inputs and the image labels as targets. Otherwise the classifier is a typical neural network.\n\n> **Exercise:** With the codes and labels loaded, build the classifier. Consider the codes as your inputs, each of them are 4096D vectors. You'll want to use a hidden layer and an output layer as your classifier. Remember that the output layer needs to have one unit for each class and a softmax activation function. Use the cross entropy to calculate the cost.", "_____no_output_____" ] ], [ [ "inputs_ = tf.placeholder(tf.float32, shape=[None, codes.shape[1]])\nlabels_ = tf.placeholder(tf.int64, shape=[None, labels_vecs.shape[1]])\n\n# TODO: Classifier layers and operations\nfc1 = tf.contrib.layers.fully_connected(inputs_, 1024)\nfc2 = tf.contrib.layers.fully_connected(fc1, 1024)\n\nlogits = tf.contrib.layers.fully_connected(fc2, labels_vecs.shape[1], activation_fn=None)\ncross_entropy = tf.nn.softmax_cross_entropy_with_logits(labels=labels_, logits=logits)\ncost = tf.reduce_mean(cross_entropy)\n\noptimizer = tf.train.AdamOptimizer().minimize(cost)\n\n# Operations for validation/test accuracy\npredicted = tf.nn.softmax(logits)\ncorrect_pred = tf.equal(tf.argmax(predicted, 1), tf.argmax(labels_, 1))\naccuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))", "_____no_output_____" ] ], [ [ "### Batches!\n\nHere is just a simple way to do batches. I've written it so that it includes all the data. Sometimes you'll throw out some data at the end to make sure you have full batches. Here I just extend the last batch to include the remaining data.", "_____no_output_____" ] ], [ [ "def get_batches(x, y, n_batches=10):\n \"\"\" Return a generator that yields batches from arrays x and y. \"\"\"\n batch_size = len(x)//n_batches\n \n for ii in range(0, n_batches*batch_size, batch_size):\n # If we're not on the last batch, grab data with size batch_size\n if ii != (n_batches-1)*batch_size:\n X, Y = x[ii: ii+batch_size], y[ii: ii+batch_size] \n # On the last batch, grab the rest of the data\n else:\n X, Y = x[ii:], y[ii:]\n # I love generators\n yield X, Y", "_____no_output_____" ] ], [ [ "### Training\n\nHere, we'll train the network.\n\n> **Exercise:** So far we've been providing the training code for you. Here, I'm going to give you a bit more of a challenge and have you write the code to train the network. Of course, you'll be able to see my solution if you need help. Use the `get_batches` function I wrote before to get your batches like `for x, y in get_batches(train_x, train_y)`. Or write your own!", "_____no_output_____" ] ], [ [ "saver = tf.train.Saver()\nepochs = 10\niteration = 0\n\nwith tf.Session() as sess:\n sess.run(tf.global_variables_initializer())\n \n for e in range(epochs): \n for x, y in get_batches(train_x, train_y):\n feed = {inputs_: x, labels_: y}\n loss, _ = sess.run([cost, optimizer], feed)\n print('Epoch: {}/{}'.format(e+1, epochs),\n 'Iterations: {}'.format(iteration),\n \"Loss: {}\".format(loss))\n iteration+=1\n \n if iteration%5 == 0:\n feed = {inputs_: val_x, labels_: val_y}\n loss, _ = sess.run([cost, optimizer], feed)\n print('Epoch: {}/{}'.format(e+1, epochs),\n 'Iterations: {}'.format(iteration),\n \"Val loss: {}\".format(loss))\n \n saver.save(sess, \"checkpoints/flowers.ckpt\")", "Epoch: 1/10 Iterations: 0 Loss: 4.672918796539307\nEpoch: 1/10 Iterations: 1 Loss: 29.755029678344727\nEpoch: 1/10 Iterations: 2 Loss: 45.8921012878418\nEpoch: 1/10 Iterations: 3 Loss: 25.696012496948242\nEpoch: 1/10 Iterations: 4 Loss: 28.859224319458008\nEpoch: 1/10 Iterations: 5 Val loss: 10.552411079406738\nEpoch: 1/10 Iterations: 5 Loss: 3.189404249191284\nEpoch: 1/10 Iterations: 6 Loss: 2.639348268508911\nEpoch: 1/10 Iterations: 7 Loss: 2.9115426540374756\nEpoch: 1/10 Iterations: 8 Loss: 2.798640251159668\nEpoch: 1/10 Iterations: 9 Loss: 2.4628725051879883\nEpoch: 1/10 Iterations: 10 Val loss: 1.82681405544281\nEpoch: 2/10 Iterations: 10 Loss: 1.1171455383300781\nEpoch: 2/10 Iterations: 11 Loss: 1.0355298519134521\nEpoch: 2/10 Iterations: 12 Loss: 0.47368577122688293\nEpoch: 2/10 Iterations: 13 Loss: 0.5847135782241821\nEpoch: 2/10 Iterations: 14 Loss: 0.8828096389770508\nEpoch: 2/10 Iterations: 15 Val loss: 0.8436155319213867\nEpoch: 2/10 Iterations: 15 Loss: 0.6585701704025269\nEpoch: 2/10 Iterations: 16 Loss: 0.556399941444397\nEpoch: 2/10 Iterations: 17 Loss: 0.487338125705719\nEpoch: 2/10 Iterations: 18 Loss: 0.4912504553794861\nEpoch: 2/10 Iterations: 19 Loss: 0.4451310634613037\nEpoch: 2/10 Iterations: 20 Val loss: 0.4065427780151367\nEpoch: 3/10 Iterations: 20 Loss: 0.34170132875442505\nEpoch: 3/10 Iterations: 21 Loss: 0.4052823781967163\nEpoch: 3/10 Iterations: 22 Loss: 0.2879161238670349\nEpoch: 3/10 Iterations: 23 Loss: 0.3895888924598694\nEpoch: 3/10 Iterations: 24 Loss: 0.3391869366168976\nEpoch: 3/10 Iterations: 25 Val loss: 0.2961403727531433\nEpoch: 3/10 Iterations: 25 Loss: 0.30506736040115356\nEpoch: 3/10 Iterations: 26 Loss: 0.25008511543273926\nEpoch: 3/10 Iterations: 27 Loss: 0.22011327743530273\nEpoch: 3/10 Iterations: 28 Loss: 0.24098922312259674\nEpoch: 3/10 Iterations: 29 Loss: 0.26284387707710266\nEpoch: 3/10 Iterations: 30 Val loss: 0.22571401298046112\nEpoch: 4/10 Iterations: 30 Loss: 0.21583987772464752\nEpoch: 4/10 Iterations: 31 Loss: 0.22172130644321442\nEpoch: 4/10 Iterations: 32 Loss: 0.161707803606987\nEpoch: 4/10 Iterations: 33 Loss: 0.1930975317955017\nEpoch: 4/10 Iterations: 34 Loss: 0.17036172747612\nEpoch: 4/10 Iterations: 35 Val loss: 0.16700726747512817\nEpoch: 4/10 Iterations: 35 Loss: 0.17953141033649445\nEpoch: 4/10 Iterations: 36 Loss: 0.1555631011724472\nEpoch: 4/10 Iterations: 37 Loss: 0.12652190029621124\nEpoch: 4/10 Iterations: 38 Loss: 0.12226159125566483\nEpoch: 4/10 Iterations: 39 Loss: 0.16163228452205658\nEpoch: 4/10 Iterations: 40 Val loss: 0.11334959417581558\nEpoch: 5/10 Iterations: 40 Loss: 0.11021738499403\nEpoch: 5/10 Iterations: 41 Loss: 0.12303079664707184\nEpoch: 5/10 Iterations: 42 Loss: 0.08418866246938705\nEpoch: 5/10 Iterations: 43 Loss: 0.11311700195074081\nEpoch: 5/10 Iterations: 44 Loss: 0.08980914205312729\nEpoch: 5/10 Iterations: 45 Val loss: 0.07618114352226257\nEpoch: 5/10 Iterations: 45 Loss: 0.09904886037111282\nEpoch: 5/10 Iterations: 46 Loss: 0.0816163569688797\nEpoch: 5/10 Iterations: 47 Loss: 0.06527123600244522\nEpoch: 5/10 Iterations: 48 Loss: 0.07217283546924591\nEpoch: 5/10 Iterations: 49 Loss: 0.0818411335349083\nEpoch: 5/10 Iterations: 50 Val loss: 0.050673067569732666\nEpoch: 6/10 Iterations: 50 Loss: 0.055724550038576126\nEpoch: 6/10 Iterations: 51 Loss: 0.056342266499996185\nEpoch: 6/10 Iterations: 52 Loss: 0.04057794064283371\nEpoch: 6/10 Iterations: 53 Loss: 0.07455720007419586\nEpoch: 6/10 Iterations: 54 Loss: 0.05536913871765137\nEpoch: 6/10 Iterations: 55 Val loss: 0.032396264374256134\nEpoch: 6/10 Iterations: 55 Loss: 0.05769611522555351\nEpoch: 6/10 Iterations: 56 Loss: 0.04174236208200455\nEpoch: 6/10 Iterations: 57 Loss: 0.03454503044486046\nEpoch: 6/10 Iterations: 58 Loss: 0.03190534561872482\nEpoch: 6/10 Iterations: 59 Loss: 0.039301518350839615\nEpoch: 6/10 Iterations: 60 Val loss: 0.027403196319937706\nEpoch: 7/10 Iterations: 60 Loss: 0.03119419328868389\nEpoch: 7/10 Iterations: 61 Loss: 0.03252197429537773\nEpoch: 7/10 Iterations: 62 Loss: 0.02040104568004608\nEpoch: 7/10 Iterations: 63 Loss: 0.02649182826280594\nEpoch: 7/10 Iterations: 64 Loss: 0.02423202432692051\nEpoch: 7/10 Iterations: 65 Val loss: 0.01874398998916149\nEpoch: 7/10 Iterations: 65 Loss: 0.04282507300376892\nEpoch: 7/10 Iterations: 66 Loss: 0.035250939428806305\nEpoch: 7/10 Iterations: 67 Loss: 0.020883135497570038\nEpoch: 7/10 Iterations: 68 Loss: 0.01988316886126995\nEpoch: 7/10 Iterations: 69 Loss: 0.01939186453819275\nEpoch: 7/10 Iterations: 70 Val loss: 0.013688798993825912\nEpoch: 8/10 Iterations: 70 Loss: 0.02058236673474312\nEpoch: 8/10 Iterations: 71 Loss: 0.025333741679787636\nEpoch: 8/10 Iterations: 72 Loss: 0.02040153741836548\nEpoch: 8/10 Iterations: 73 Loss: 0.03184022754430771\nEpoch: 8/10 Iterations: 74 Loss: 0.012570078484714031\nEpoch: 8/10 Iterations: 75 Val loss: 0.006841983646154404\nEpoch: 8/10 Iterations: 75 Loss: 0.015580104663968086\nEpoch: 8/10 Iterations: 76 Loss: 0.014343924820423126\nEpoch: 8/10 Iterations: 77 Loss: 0.018154548481106758\nEpoch: 8/10 Iterations: 78 Loss: 0.025013182312250137\nEpoch: 8/10 Iterations: 79 Loss: 0.028149407356977463\nEpoch: 8/10 Iterations: 80 Val loss: 0.006597414147108793\nEpoch: 9/10 Iterations: 80 Loss: 0.00860650185495615\nEpoch: 9/10 Iterations: 81 Loss: 0.00733830314129591\nEpoch: 9/10 Iterations: 82 Loss: 0.00633214833214879\nEpoch: 9/10 Iterations: 83 Loss: 0.014129566960036755\nEpoch: 9/10 Iterations: 84 Loss: 0.008173373527824879\nEpoch: 9/10 Iterations: 85 Val loss: 0.007537458091974258\nEpoch: 9/10 Iterations: 85 Loss: 0.01679036393761635\nEpoch: 9/10 Iterations: 86 Loss: 0.00960800051689148\nEpoch: 9/10 Iterations: 87 Loss: 0.005559608340263367\nEpoch: 9/10 Iterations: 88 Loss: 0.005612092092633247\nEpoch: 9/10 Iterations: 89 Loss: 0.010039210319519043\nEpoch: 9/10 Iterations: 90 Val loss: 0.002736186608672142\nEpoch: 10/10 Iterations: 90 Loss: 0.005322793032974005\nEpoch: 10/10 Iterations: 91 Loss: 0.0052515072748064995\nEpoch: 10/10 Iterations: 92 Loss: 0.013230983167886734\nEpoch: 10/10 Iterations: 93 Loss: 0.01197117194533348\nEpoch: 10/10 Iterations: 94 Loss: 0.0041971355676651\nEpoch: 10/10 Iterations: 95 Val loss: 0.0022358843125402927\nEpoch: 10/10 Iterations: 95 Loss: 0.004806811455637217\nEpoch: 10/10 Iterations: 96 Loss: 0.0033794238697737455\nEpoch: 10/10 Iterations: 97 Loss: 0.0032531919423490763\nEpoch: 10/10 Iterations: 98 Loss: 0.0034035572316497564\nEpoch: 10/10 Iterations: 99 Loss: 0.009972398169338703\nEpoch: 10/10 Iterations: 100 Val loss: 0.0017780129564926028\n" ] ], [ [ "### Testing\n\nBelow you see the test accuracy. You can also see the predictions returned for images.", "_____no_output_____" ] ], [ [ "with tf.Session() as sess:\n saver.restore(sess, tf.train.latest_checkpoint('checkpoints'))\n \n feed = {inputs_: test_x,\n labels_: test_y}\n test_acc = sess.run(accuracy, feed_dict=feed)\n print(\"Test accuracy: {:.4f}\".format(test_acc))", "Test accuracy: 0.9591\n" ], [ "%matplotlib inline\n\nimport matplotlib.pyplot as plt\nfrom scipy.ndimage import imread", "_____no_output_____" ] ], [ [ "Below, feel free to choose images and see how the trained classifier predicts the flowers in them.", "_____no_output_____" ] ], [ [ "test_img_path = 'flower_photos/roses/10894627425_ec76bbc757_n.jpg'\ntest_img = imread(test_img_path)\nplt.imshow(test_img)", "_____no_output_____" ], [ "# Run this cell if you don't have a vgg graph built\nif 'vgg' in globals():\n print('\"vgg\" object already exists. Will not create again.')\nelse:\n #create vgg\n with tf.Session() as sess:\n input_ = tf.placeholder(tf.float32, [None, 224, 224, 3])\n vgg = vgg16.Vgg16()\n vgg.build(input_)", "\"vgg\" object already exists. Will not create again.\n" ], [ "with tf.Session() as sess:\n img = utils.load_image(test_img_path)\n img = img.reshape((1, 224, 224, 3))\n\n feed_dict = {input_: img}\n code = sess.run(vgg.relu6, feed_dict=feed_dict)\n \nsaver = tf.train.Saver()\nwith tf.Session() as sess:\n saver.restore(sess, tf.train.latest_checkpoint('checkpoints'))\n \n feed = {inputs_: code}\n prediction = sess.run(predicted, feed_dict=feed).squeeze()", "_____no_output_____" ], [ "plt.imshow(test_img)", "_____no_output_____" ], [ "plt.barh(np.arange(5), prediction)\n_ = plt.yticks(np.arange(5), lb.classes_)", "_____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", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown", "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code" ], [ "markdown" ], [ "code", "code" ], [ "markdown" ], [ "code", "code", "code", "code", "code" ] ]

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "import pandas as pd", "_____no_output_____" ], [ "df_caged = pd.read_csv(\"data/CAGEDEST_102019.txt\", sep=';', encoding='iso8859-1')", "/home/chris/anaconda3/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3049: DtypeWarning: Columns (32,33,34,35,36,37,38,39) have mixed types. Specify dtype option on import or set low_memory=False.\n interactivity=interactivity, compiler=compiler, result=result)\n" ], [ "print(df_caged.shape)\ndf_caged.head()", "(2659256, 42)\n" ], [ "df_caged.columns", "_____no_output_____" ], [ "df_caged['CNAE 2.0 Subclas'].value_counts()[:15].plot.bar(figsize=(20,10));", "_____no_output_____" ], [ "df_caged.UF.value_counts()[:15].plot.bar(figsize=(20,10));", "_____no_output_____" ] ] ]

[ "code" ]

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Melanoma Diagnoses", "_____no_output_____" ] ], [ [ "import os\nimport keras\nimport pandas as pd\nimport numpy as np\nfrom PIL import Image\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\nfrom keras import applications\nfrom keras.preprocessing.image import ImageDataGenerator\nfrom keras.preprocessing import image\nfrom keras import optimizers\nfrom keras.models import Sequential, Model \nfrom keras.layers import Dropout, Flatten, Dense, GlobalAveragePooling2D\nfrom keras import backend as k \nfrom keras.callbacks import ModelCheckpoint, LearningRateScheduler, TensorBoard, EarlyStopping\nfrom keras.models import load_model\n\nfrom sklearn.metrics import roc_curve, auc\n\nimport get_results\n", "Using TensorFlow backend.\n" ] ], [ [ "### Import Images", "_____no_output_____" ] ], [ [ "def load_image( infilename ) :\n img = Image.open( infilename )\n img.load()\n data = np.asarray( img, dtype=\"float32\" )\n return data\n\ndata_dir = 'data'\ntrain_dir = data_dir + '/train'\nvalid_dir = data_dir + '/valid'\ntest_dir = data_dir + '/test'", "_____no_output_____" ], [ "fig = plt.figure(figsize=(20,5))\ntrain_files = os.listdir(train_dir+\"/melanoma\")[:5]\nfor i in range(5):\n ax = fig.add_subplot(3, 12, i + 1, xticks=[], yticks=[])\n ax.imshow(load_image(train_dir + \"/melanoma/\" +train_files[i]))", "_____no_output_____" ] ], [ [ "### Image Data transformation", "_____no_output_____" ] ], [ [ "img_width, img_height = 256, 256\nbatch_size = 16\nepochs = 10\n\ntrain_datagen = ImageDataGenerator(\n rescale = 1./255,\n horizontal_flip = True,\n# fill_mode = \"nearest\",\n zoom_range = 0.2,\n# width_shift_range = 0.3,\n# height_shift_range=0.3,\n shear_range=0.2,\n# rotation_range=30\n)\n\ntest_datagen = ImageDataGenerator(rescale = 1./255)\n\ntrain_generator = train_datagen.flow_from_directory(\n train_dir,\n target_size = (img_height, img_width),\n batch_size = batch_size, \n class_mode = \"categorical\")\n\nvalidation_generator = test_datagen.flow_from_directory(\n valid_dir,\n target_size = (img_height, img_width),\n class_mode = \"categorical\")\n\ntest_generator = test_datagen.flow_from_directory(\n test_dir,\n target_size = (img_height, img_width),\n class_mode = \"categorical\")", "Found 0 images belonging to 0 classes.\nFound 0 images belonging to 0 classes.\nFound 600 images belonging to 3 classes.\n" ], [ "train_generator.image_shape", "_____no_output_____" ] ], [ [ "### Fine-tune Model", "_____no_output_____" ] ], [ [ "# create the base pre-trained model\nvgg_model = applications.VGG19(weights = \"imagenet\", \n include_top=False, \n input_shape = (img_width, img_height, 3))\nfor layer in vgg_model.layers[:5]:\n layer.trainable = False\n\n#Adding custom Layers \nx = vgg_model.output\nx = GlobalAveragePooling2D()(x)\n# add fully-connected layer\nx = Dense(512, activation='relu')(x)\nx = Dropout(0.5)(x)\n\n# add output layer\npredictions = Dense(3, activation='softmax')(x)\n\nmodel_final = Model(inputs=vgg_model.input, outputs=predictions)\n\n# freeze pre-trained model area's layer\nfor layer in vgg_model.layers:\n layer.trainable = False\n\n# update the weight that are added\nmodel_final.compile(optimizer='rmsprop', loss='categorical_crossentropy')", "_____no_output_____" ], [ "model_final.fit_generator(\n train_generator,\n steps_per_epoch=train_generator.samples/train_generator.batch_size,\n epochs = 3,\n validation_data = validation_generator,\n validation_steps = validation_generator.samples/validation_generator.batch_size)", "Epoch 1/3\n125/125 [==============================] - 325s - loss: 0.8962 - val_loss: 1.2098\nEpoch 2/3\n125/125 [==============================] - 309s - loss: 0.8286 - val_loss: 1.2344\nEpoch 3/3\n125/125 [==============================] - 302s - loss: 0.8126 - val_loss: 1.1027\n" ] ], [ [ "### Train Model", "_____no_output_____" ] ], [ [ "# Save the model according to the conditions \ncheckpoint = ModelCheckpoint(\"cancer_vgg19_wt.h5\", \n monitor='val_acc', verbose=2, \n save_best_only=True, save_weights_only=False, \n mode='auto', period=1)\nearly = EarlyStopping(monitor='val_acc', \n min_delta=0, patience=3, \n verbose=2, mode='auto')\n\n# choose the layers which are updated by training\nlayer_num = len(model_final.layers)\nfor layer in model_final.layers[:21]:\n layer.trainable = False\n\nfor layer in model_final.layers[21:]:\n layer.trainable = True\n\n# training\nmodel_final.compile(optimizer=optimizers.SGD(lr=0.001, momentum=0.9), \n loss='categorical_crossentropy', metrics=['accuracy'])\n\n# Train the model \nmodel_final.fit_generator(\n train_generator,\n steps_per_epoch = train_generator.samples/train_generator.batch_size,\n epochs = epochs,\n validation_data = validation_generator,\n validation_steps = validation_generator.samples/validation_generator.batch_size,\n callbacks = [checkpoint, early])", "Epoch 1/10\n124/125 [============================>.] - ETA: 2s - loss: 0.7818 - acc: 0.6885Epoch 00000: val_acc improved from -inf to 0.52000, saving model to cancer_vgg19_wt.h5\n125/125 [==============================] - 332s - loss: 0.7812 - acc: 0.6895 - val_loss: 1.0943 - val_acc: 0.5200\nEpoch 2/10\n124/125 [============================>.] - ETA: 2s - loss: 0.7781 - acc: 0.6910Epoch 00001: val_acc did not improve\n125/125 [==============================] - 303s - loss: 0.7773 - acc: 0.6915 - val_loss: 1.1254 - val_acc: 0.5133\nEpoch 3/10\n124/125 [============================>.] - ETA: 2s - loss: 0.7872 - acc: 0.6799Epoch 00002: val_acc did not improve\n125/125 [==============================] - 302s - loss: 0.7872 - acc: 0.6800 - val_loss: 0.9755 - val_acc: 0.5200\nEpoch 4/10\n124/125 [============================>.] - ETA: 2s - loss: 0.7709 - acc: 0.6835Epoch 00003: val_acc did not improve\n125/125 [==============================] - 306s - loss: 0.7718 - acc: 0.6830 - val_loss: 1.0606 - val_acc: 0.5200\nEpoch 5/10\n124/125 [============================>.] - ETA: 2s - loss: 0.7698 - acc: 0.6920Epoch 00004: val_acc did not improve\n125/125 [==============================] - 306s - loss: 0.7703 - acc: 0.6915 - val_loss: 1.0909 - val_acc: 0.4867\nEpoch 00004: early stopping\n" ], [ "model_final.save('cancer_vgg19_model.h5')", "_____no_output_____" ], [ "model_final = load_model('cancer_vgg19_model.h5')", "_____no_output_____" ], [ "img_path = 'data/test/nevus/ISIC_0012803.jpg'\nimg = image.load_img(img_path, target_size=(256, 256))\nx = image.img_to_array(img)\nx = np.expand_dims(x, axis=0)\nx = test_datagen.standardize(x)\nmodel_final.predict(x, verbose=2)", "_____no_output_____" ], [ "img_path = 'data/test/melanoma/ISIC_0012989.jpg'\nimg = image.load_img(img_path, target_size=(256, 256))\nx = image.img_to_array(img)\nx = np.expand_dims(x, axis=0)\nx = test_datagen.standardize(x)\nmodel_final.predict(x, verbose=2)", "_____no_output_____" ], [ "img_path = 'data/test/seborrheic_keratosis/ISIC_0012323.jpg'\nimg = image.load_img(img_path, target_size=(256, 256))\nx = image.img_to_array(img)\nx = np.expand_dims(x, axis=0)\nx = test_datagen.standardize(x)\nmodel_final.predict(x, verbose=2)", "_____no_output_____" ], [ "model_final.evaluate_generator(test_generator, \n steps = test_generator.samples/test_generator.batch_size)", "_____no_output_____" ], [ "y_hat = model_final.predict_generator(test_generator, \n steps = test_generator.samples/test_generator.batch_size)", "_____no_output_____" ], [ "def get_pred(img_path):\n img = image.load_img(img_path, target_size=(256, 256))\n x = image.img_to_array(img)\n x = np.expand_dims(x, axis=0)\n x = test_datagen.standardize(x)\n return model_final.predict(x)\n\ntest_files = pd.read_csv('sample_predictions.csv')\nfor index, row in test_files.iterrows():\n pred = get_pred(row['Id'])\n test_files.loc[index, 'task_1'] = pred[0][0]\n test_files.loc[index, 'task_2'] = pred[0][2]\n \ntest_files.head()", "_____no_output_____" ], [ "test_files.to_csv('submission_predictions.csv')", "_____no_output_____" ] ], [ [ "Category 1 Score: 0.554<br>\nCategory 2 Score: 0.659<br>\nCategory 3 Score: 0.607", "_____no_output_____" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n<div class=\"toc\"><ul class=\"toc-item\"></ul></div>", "_____no_output_____" ] ], [ [ "import geopandas\nimport plotly", "_____no_output_____" ] ] ]

[ "markdown", "code" ]

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Section 4", "_____no_output_____" ], [ "# Try another name\nYou are still working on your Twitter sentiment analysis. You analyze now some things that caught your attention. You noticed that there are email addresses inserted in some tweets. Now, you are curious to find out which is the most common name.\n\nYou want to extract the first part of the email. E.g. if you have the email [email protected], you are only interested in marysmith90.\nYou need to match the entire expression. So you make sure to extract only names present in emails. Also, you are only interested in names containing upper (e.g. A,B, Z) or lowercase letters (e.g. a, d, z) and numbers.\n\nThe list sentiment_analysis containing the text of three tweets as well as the re module were loaded in your session. You can use print() to view it in the IPython Shell.", "_____no_output_____" ] ], [ [ "sentiment_analysis = ['Just got ur newsletter, those fares really are unbelievable. Write to [email protected] or [email protected]. They have amazing prices',\n 'I should have paid more attention when we covered photoshop in my webpage design class in undergrad. Contact me [email protected].',\n 'hey missed ya at the meeting. Read your email! [email protected]']", "_____no_output_____" ], [ "import re\n\n# Write a regex that matches email\nregex_email = r\"([A-Za-z0-9]+)@\\S+\"\n\nfor tweet in sentiment_analysis:\n # Find all matches of regex in each tweet\n email_matched = re.findall(regex_email, tweet)\n\n # Complete the format method to print the results\n print(\"Lists of users found in this tweet: {}\".format(email_matched))", "Lists of users found in this tweet: ['statravelAU', 'statravelpo']\nLists of users found in this tweet: ['Hollywoodheat34']\nLists of users found in this tweet: ['msdrama098']\n" ] ], [ [ "# Flying home\nYour boss assigned you to a small project. They are performing an analysis of the travels people made to attend business meetings. You are given a dataset with only the email subjects for each of the people traveling.\n\nYou learn that the text followed a pattern. Here is an example:\n\nHere you have your boarding pass LA4214 AER-CDB 06NOV.\n\nYou need to extract the information about the flight:\n\n- The two letters indicate the airline (e.g LA),\n- The 4 numbers are the flight number (e.g. 4214).\n- The three letters correspond to the departure (e.g AER),\n- The destination (CDB),\n- The date (06NOV) of the flight.\n- All letters are always uppercase.\n\nThe variable flight containing one email subject was loaded in your session. You can use print() to view it in the IPython Shell.", "_____no_output_____" ] ], [ [ "# Import re\nimport re", "_____no_output_____" ], [ "# Write regex to capture information of the flight\nregex = r\"([A-Z]{2})(\\d{4})\\s([A-Z]{3})-([A-Z]{3})\\s(\\d{2}[A-Z]{3})\"", "_____no_output_____" ], [ "flight = 'Subject: You are now ready to fly. Here you have your boarding pass IB3723 AMS-MAD 06OCT'\n# Find all matches of the flight information\nflight_matches = re.findall(regex, flight)", "_____no_output_____" ], [ "#Print the matches\nprint(\"Airline: {} Flight number: {}\".format(flight_matches[0][0], flight_matches[0][1]))\nprint(\"Departure: {} Destination: {}\".format(flight_matches[0][2], flight_matches[0][3]))\nprint(\"Date: {}\".format(flight_matches[0][4]))", "Airline: IB Flight number: 3723\nDeparture: AMS Destination: MAD\nDate: 06OCT\n" ] ], [ [ "# Love it!\nYou are still working on the Twitter sentiment analysis project. First, you want to identify positive tweets about movies and concerts.\n\nYou plan to find all the sentences that contain the words love, like, or enjoy and capture that word. You will limit the tweets by focusing on those that contain the words movie or concert by keeping the word in another group. You will also save the movie or concert name.\n\nFor example, if you have the sentence: I love the movie Avengers. You match and capture love. You need to match and capture movie. Afterwards, you match and capture anything until the dot.\n\nThe list sentiment_analysis containing the text of three tweets and the re module are loaded in your session. You can use print() to view the data in the IPython Shell.", "_____no_output_____" ] ], [ [ "sentiment_analysis = ['I totally love the concert The Book of Souls World Tour. It kinda amazing!',\n 'I enjoy the movie Wreck-It Ralph. I watched with my boyfriend.',\n \"I still like the movie Wish Upon a Star. Too bad Disney doesn't show it anymore.\"]", "_____no_output_____" ], [ "# Write a regex that matches sentences with the optional words\nregex_positive = r\"(love|like|enjoy).+?(movie|concert)\\s(.+?)\\.\"\n\nfor tweet in sentiment_analysis:\n\t# Find all matches of regex in tweet\n positive_matches = re.findall(regex_positive, tweet)\n \n # Complete format to print out the results\n print(\"Positive comments found {}\".format(positive_matches))", "Positive comments found [('love', 'concert', 'The Book of Souls World Tour')]\nPositive comments found [('enjoy', 'movie', 'Wreck-It Ralph')]\nPositive comments found [('like', 'movie', 'Wish Upon a Star')]\n" ] ], [ [ "# Ugh! Not for me!\nAfter finding positive tweets, you want to do it for negative tweets. Your plan now is to find sentences that contain the words hate, dislike or disapprove. You will again save the movie or concert name. You will get the tweet containing the words movie or concert but this time, you don't plan to save the word.\n\nFor example, if you have the sentence: I dislike the movie Avengers a lot.. You match and capture dislike. You will match but not capture the word movie. Afterwards, you match and capture anything until the dot.\n\nThe list sentiment_analysis containing the text of three tweets as well as the re module are loaded in your session. You can use print() to view the data in the IPython Shell.", "_____no_output_____" ] ], [ [ "sentiment_analysis = ['That was horrible! I really dislike the movie The cabin and the ant. So boring.',\n \"I disapprove the movie Honest with you. It's full of cliches.\",\n 'I dislike very much the concert After twelve Tour. The sound was horrible.']", "_____no_output_____" ], [ "# Write a regex that matches sentences with the optional words\nregex_negative = r\"(hate|dislike|disapprove).+?(?:movie|concert)\\s(.+?)\\.\"\n\nfor tweet in sentiment_analysis:\n\t# Find all matches of regex in tweet\n negative_matches = re.findall(regex_negative, tweet)\n \n # Complete format to print out the results\n print(\"Negative comments found {}\".format(negative_matches))", "Negative comments found [('dislike', 'The cabin and the ant')]\nNegative comments found [('disapprove', 'Honest with you')]\nNegative comments found [('dislike', 'After twelve Tour')]\n" ] ], [ [ "# Parsing PDF files\nYou now need to work on another small project you have been delaying. Your company gave you some PDF files of signed contracts. The goal of the project is to create a database with the information you parse from them. Three of these columns should correspond to the day, month, and year when the contract was signed.\nThe dates appear as Signed on 05/24/2016 (05 indicating the month, 24 the day). You decide to use capturing groups to extract this information. Also, you would like to retrieve that information so you can store it separately in different variables.\n\nYou decide to do a proof of concept.\n\nThe variable contract containing the text of one contract and the re module are already loaded in your session. You can use print() to view the data in the IPython Shell.", "_____no_output_____" ] ], [ [ "contract = 'Provider will invoice Client for Services performed within 30 days of performance. Client will pay Provider as set forth in each Statement of Work within 30 days of receipt and acceptance of such invoice. It is understood that payments to Provider for services rendered shall be made in full as agreed, without any deductions for taxes of any kind whatsoever, in conformity with Provider’s status as an independent contractor. Signed on 03/25/2001.'\n# Write regex and scan contract to capture the dates described\nregex_dates = r\"Signed\\son\\s(\\d{2})/(\\d{2})/(\\d{4})\"\ndates = re.search(regex_dates, contract)", "_____no_output_____" ], [ "# Assign to each key the corresponding match\nsignature = {\n\t\"day\": dates.group(2),\n\t\"month\": dates.group(1),\n\t\"year\": dates.group(3)\n}", "_____no_output_____" ], [ "# Complete the format method to print-out\nprint(\"Our first contract is dated back to {data[year]}. Particularly, the day {data[day]} of the month {data[month]}.\".format(data=signature))", "Our first contract is dated back to 2001. Particularly, the day 25 of the month 03.\n" ] ], [ [ "# Close the tag, please!\nIn the meantime, you are working on one of your other projects. The company is going to develop a new product. It will help developers automatically check the code they are writing. You need to write a short script for checking that every HTML tag that is open has its proper closure.\n\nYou have an example of a string containing HTML tags:\n\n<title>The Data Science Company</title>\n\nYou learn that an opening HTML tag is always at the beginning of the string. It appears inside <>. A closing tag also appears inside <>, but it is preceded by /.\n\nYou also remember that capturing groups can be referenced using numbers, e.g \\4.\n\nThe list html_tags, containing three strings with HTML tags, and there module are loaded in your session. You can use print() to view the data in the IPython Shell.", "_____no_output_____" ] ], [ [ "html_tags = ['<body>Welcome to our course! It would be an awesome experience</body>',\n '<article>To be a data scientist, you need to have knowledge in statistics and mathematics</article>',\n '<nav>About me Links Contact me!']", "_____no_output_____" ], [ "for string in html_tags:\n # Complete the regex and find if it matches a closed HTML tags\n match_tag = re.match(r\"<(\\w+)>.*?</\\1>\", string)\n \n if match_tag:\n # If it matches print the first group capture\n print(\"Your tag {} is closed\".format(match_tag.group(1))) \n else:\n # If it doesn't match capture only the tag \n notmatch_tag = re.match(r\"<(\\w+)>\", string)\n # Print the first group capture\n print(\"Close your {} tag!\".format(notmatch_tag.group(1)))", "Your tag body is closed\nYour tag article is closed\nClose your nav tag!\n" ] ], [ [ "# Reeepeated characters\nBack to your sentiment analysis! Your next task is to replace elongated words that appear in the tweets. We define an elongated word as a word that contains a repeating character twice or more times. e.g. \"Awesoooome\".\n\nReplacing those words is very important since a classifier will treat them as a different term from the source words lowering their frequency.\n\nTo find them, you will use capturing groups and reference them back using numbers. E.g \\4.\n\nIf you want to find a match for Awesoooome. You first need to capture Awes. Then, match o and reference the same character back, and then, me.\n\nThe list sentiment_analysis, containing the text of three tweets, and the re module are loaded in your session. You can use print() to view the data in the IPython Shell.", "_____no_output_____" ] ], [ [ "sentiment_analysis = ['@marykatherine_q i know! I heard it this morning and wondered the same thing. Moscooooooow is so behind the times',\n 'Staying at a friends house...neighborrrrrrrs are so loud-having a party',\n 'Just woke up an already have read some e-mail']", "_____no_output_____" ], [ "# Complete the regex to match an elongated word\nregex_elongated = r\"\\w*(\\w)\\1\\w*\"\n\nfor tweet in sentiment_analysis:\n\t# Find if there is a match in each tweet \n\tmatch_elongated = re.search(regex_elongated, tweet)\n \n\tif match_elongated:\n\t\t# Assign the captured group zero \n\t\telongated_word = match_elongated.group(0)\n \n\t\t# Complete the format method to print the word\n\t\tprint(\"Elongated word found: {word}\".format(word=elongated_word))\n\telse:\n\t\tprint(\"No elongated word found\")", "Elongated word found: Moscooooooow\nElongated word found: neighborrrrrrrs\nNo elongated word found\n" ] ], [ [ "# Surrounding words\nNow, you want to perform some visualizations with your sentiment_analysis dataset. You are interested in the words surrounding python. You want to count how many times a specific words appears right before and after it.\n\nPositive lookahead (?=) makes sure that first part of the expression is followed by the lookahead expression. Positive lookbehind (?<=) returns all matches that are preceded by the specified pattern.\n\nThe variable sentiment_analysis, containing the text of one tweet, and the re module are loaded in your session. You can use print() to view the data in the IPython Shell.", "_____no_output_____" ] ], [ [ "sentiment_analysis = 'You need excellent python skills to be a data scientist. Must be! Excellent python'", "_____no_output_____" ], [ "# Positive lookahead\nlook_ahead = re.findall(r\"\\w+(?=\\spython)\", sentiment_analysis)\n\n# Print out\nprint(look_ahead)", "['excellent', 'Excellent']\n" ], [ "# Positive lookbehind\nlook_behind = re.findall(r\"(?<=[Pp]ython\\s)\\w+\", sentiment_analysis)\n\n# Print out\nprint(look_behind)", "['skills']\n" ] ], [ [ "# Filtering phone numbers\nNow, you need to write a script for a cell-phone searcher. It should scan a list of phone numbers and return those that meet certain characteristics.\n\nThe phone numbers in the list have the structure:\n\n- Optional area code: 3 numbers\n- Prefix: 4 numbers\n- Line number: 6 numbers\n- Optional extension: 2 numbers\n\nE.g. 654-8764-439434-01.\n\nYou decide to use .findall() and the non-capturing group's negative lookahead (?!) and negative lookbehind (?<!).\n\nThe list cellphones, containing three phone numbers, and the re module are loaded in your session. You can use print() to view the data in the IPython Shell.", "_____no_output_____" ] ], [ [ "cellphones = ['4564-646464-01', '345-5785-544245', '6476-579052-01']", "_____no_output_____" ], [ "for phone in cellphones:\n\t# Get all phone numbers not preceded by area code\n\tnumber = re.findall(r\"(?<!\\d{3}-)\\d{4}-\\d{6}-\\d{2}\", phone)\n\tprint(number)", "['4564-646464-01']\n[]\n['6476-579052-01']\n" ], [ "for phone in cellphones:\n\t# Get all phone numbers not followed by optional extension\n\tnumber = re.findall(r\"\\d{3}-\\d{4}-\\d{6}(?!-\\d{2})\", phone)\n\tprint(number)", "[]\n['345-5785-544245']\n[]\n" ] ] ]

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

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

[ "MIT" ]

[ "MIT" ]

[ "MIT" ]

[ [ [ "# Batch Normalization – Lesson\n\n1. [What is it?](#theory)\n2. [What are it's benefits?](#benefits)\n3. [How do we add it to a network?](#implementation_1)\n4. [Let's see it work!](#demos)\n5. [What are you hiding?](#implementation_2)\n\n# What is Batch Normalization?<a id='theory'></a>\n\nBatch normalization was introduced in Sergey Ioffe's and Christian Szegedy's 2015 paper [Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift](https://arxiv.org/pdf/1502.03167.pdf). The idea is that, instead of just normalizing the inputs to the network, we normalize the inputs to _layers within_ the network. It's called \"batch\" normalization because during training, we normalize each layer's inputs by using the mean and variance of the values in the current mini-batch.\n\nWhy might this help? Well, we know that normalizing the inputs to a _network_ helps the network learn. But a network is a series of layers, where the output of one layer becomes the input to another. That means we can think of any layer in a neural network as the _first_ layer of a smaller network.\n\nFor example, imagine a 3 layer network. Instead of just thinking of it as a single network with inputs, layers, and outputs, think of the output of layer 1 as the input to a two layer network. This two layer network would consist of layers 2 and 3 in our original network. \n\nLikewise, the output of layer 2 can be thought of as the input to a single layer network, consisting only of layer 3.\n\nWhen you think of it like that - as a series of neural networks feeding into each other - then it's easy to imagine how normalizing the inputs to each layer would help. It's just like normalizing the inputs to any other neural network, but you're doing it at every layer (sub-network).\n\nBeyond the intuitive reasons, there are good mathematical reasons why it helps the network learn better, too. It helps combat what the authors call _internal covariate shift_. This discussion is best handled [in the paper](https://arxiv.org/pdf/1502.03167.pdf) and in [Deep Learning](http://www.deeplearningbook.org) a book you can read online written by Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Specifically, check out the batch normalization section of [Chapter 8: Optimization for Training Deep Models](http://www.deeplearningbook.org/contents/optimization.html).", "_____no_output_____" ], [ "# Benefits of Batch Normalization<a id=\"benefits\"></a>\n\nBatch normalization optimizes network training. It has been shown to have several benefits:\n1. **Networks train faster** – Each training _iteration_ will actually be slower because of the extra calculations during the forward pass and the additional hyperparameters to train during back propagation. However, it should converge much more quickly, so training should be faster overall. \n2. **Allows higher learning rates** – Gradient descent usually requires small learning rates for the network to converge. And as networks get deeper, their gradients get smaller during back propagation so they require even more iterations. Using batch normalization allows us to use much higher learning rates, which further increases the speed at which networks train. \n3. **Makes weights easier to initialize** – Weight initialization can be difficult, and it's even more difficult when creating deeper networks. Batch normalization seems to allow us to be much less careful about choosing our initial starting weights. \n4. **Makes more activation functions viable** – Some activation functions do not work well in some situations. Sigmoids lose their gradient pretty quickly, which means they can't be used in deep networks. And ReLUs often die out during training, where they stop learning completely, so we need to be careful about the range of values fed into them. Because batch normalization regulates the values going into each activation function, non-linearlities that don't seem to work well in deep networks actually become viable again. \n5. **Simplifies the creation of deeper networks** – Because of the first 4 items listed above, it is easier to build and faster to train deeper neural networks when using batch normalization. And it's been shown that deeper networks generally produce better results, so that's great.\n6. **Provides a bit of regularlization** – Batch normalization adds a little noise to your network. In some cases, such as in Inception modules, batch normalization has been shown to work as well as dropout. But in general, consider batch normalization as a bit of extra regularization, possibly allowing you to reduce some of the dropout you might add to a network. \n7. **May give better results overall** – Some tests seem to show batch normalization actually improves the training results. However, it's really an optimization to help train faster, so you shouldn't think of it as a way to make your network better. But since it lets you train networks faster, that means you can iterate over more designs more quickly. It also lets you build deeper networks, which are usually better. So when you factor in everything, you're probably going to end up with better results if you build your networks with batch normalization.", "_____no_output_____" ], [ "# Batch Normalization in TensorFlow<a id=\"implementation_1\"></a>\n\nThis section of the notebook shows you one way to add batch normalization to a neural network built in TensorFlow. \n\nThe following cell imports the packages we need in the notebook and loads the MNIST dataset to use in our experiments. However, the `tensorflow` package contains all the code you'll actually need for batch normalization.", "_____no_output_____" ] ], [ [ "# Import necessary packages\nimport tensorflow as tf\nimport tqdm\nimport numpy as np\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n# Import MNIST data so we have something for our experiments\nfrom tensorflow.examples.tutorials.mnist import input_data\nmnist = input_data.read_data_sets(\"MNIST_data/\", one_hot=True)", "Successfully downloaded train-images-idx3-ubyte.gz 9912422 bytes.\nExtracting MNIST_data/train-images-idx3-ubyte.gz\nSuccessfully downloaded train-labels-idx1-ubyte.gz 28881 bytes.\nExtracting MNIST_data/train-labels-idx1-ubyte.gz\nSuccessfully downloaded t10k-images-idx3-ubyte.gz 1648877 bytes.\nExtracting MNIST_data/t10k-images-idx3-ubyte.gz\nSuccessfully downloaded t10k-labels-idx1-ubyte.gz 4542 bytes.\nExtracting MNIST_data/t10k-labels-idx1-ubyte.gz\n" ] ], [ [ "### Neural network classes for testing\n\nThe following class, `NeuralNet`, allows us to create identical neural networks with and without batch normalization. The code is heavily documented, but there is also some additional discussion later. You do not need to read through it all before going through the rest of the notebook, but the comments within the code blocks may answer some of your questions.\n\n*About the code:*\n>This class is not meant to represent TensorFlow best practices – the design choices made here are to support the discussion related to batch normalization.\n\n>It's also important to note that we use the well-known MNIST data for these examples, but the networks we create are not meant to be good for performing handwritten character recognition. We chose this network architecture because it is similar to the one used in the original paper, which is complex enough to demonstrate some of the benefits of batch normalization while still being fast to train.", "_____no_output_____" ] ], [ [ "class NeuralNet:\n def __init__(self, initial_weights, activation_fn, use_batch_norm):\n \"\"\"\n Initializes this object, creating a TensorFlow graph using the given parameters.\n \n :param initial_weights: list of NumPy arrays or Tensors\n Initial values for the weights for every layer in the network. We pass these in\n so we can create multiple networks with the same starting weights to eliminate\n training differences caused by random initialization differences.\n The number of items in the list defines the number of layers in the network,\n and the shapes of the items in the list define the number of nodes in each layer.\n e.g. Passing in 3 matrices of shape (784, 256), (256, 100), and (100, 10) would \n create a network with 784 inputs going into a hidden layer with 256 nodes,\n followed by a hidden layer with 100 nodes, followed by an output layer with 10 nodes.\n :param activation_fn: Callable\n The function used for the output of each hidden layer. The network will use the same\n activation function on every hidden layer and no activate function on the output layer.\n e.g. Pass tf.nn.relu to use ReLU activations on your hidden layers.\n :param use_batch_norm: bool\n Pass True to create a network that uses batch normalization; False otherwise\n Note: this network will not use batch normalization on layers that do not have an\n activation function.\n \"\"\"\n # Keep track of whether or not this network uses batch normalization.\n self.use_batch_norm = use_batch_norm\n self.name = \"With Batch Norm\" if use_batch_norm else \"Without Batch Norm\"\n\n # Batch normalization needs to do different calculations during training and inference,\n # so we use this placeholder to tell the graph which behavior to use.\n self.is_training = tf.placeholder(tf.bool, name=\"is_training\")\n\n # This list is just for keeping track of data we want to plot later.\n # It doesn't actually have anything to do with neural nets or batch normalization.\n self.training_accuracies = []\n\n # Create the network graph, but it will not actually have any real values until after you\n # call train or test\n self.build_network(initial_weights, activation_fn)\n \n def build_network(self, initial_weights, activation_fn):\n \"\"\"\n Build the graph. The graph still needs to be trained via the `train` method.\n \n :param initial_weights: list of NumPy arrays or Tensors\n See __init__ for description. \n :param activation_fn: Callable\n See __init__ for description. \n \"\"\"\n self.input_layer = tf.placeholder(tf.float32, [None, initial_weights[0].shape[0]])\n layer_in = self.input_layer\n for weights in initial_weights[:-1]:\n layer_in = self.fully_connected(layer_in, weights, activation_fn) \n self.output_layer = self.fully_connected(layer_in, initial_weights[-1])\n \n def fully_connected(self, layer_in, initial_weights, activation_fn=None):\n \"\"\"\n Creates a standard, fully connected layer. Its number of inputs and outputs will be\n defined by the shape of `initial_weights`, and its starting weight values will be\n taken directly from that same parameter. If `self.use_batch_norm` is True, this\n layer will include batch normalization, otherwise it will not. \n \n :param layer_in: Tensor\n The Tensor that feeds into this layer. It's either the input to the network or the output\n of a previous layer.\n :param initial_weights: NumPy array or Tensor\n Initial values for this layer's weights. The shape defines the number of nodes in the layer.\n e.g. Passing in 3 matrix of shape (784, 256) would create a layer with 784 inputs and 256 \n outputs. \n :param activation_fn: Callable or None (default None)\n The non-linearity used for the output of the layer. If None, this layer will not include \n batch normalization, regardless of the value of `self.use_batch_norm`. \n e.g. Pass tf.nn.relu to use ReLU activations on your hidden layers.\n \"\"\"\n # Since this class supports both options, only use batch normalization when\n # requested. However, do not use it on the final layer, which we identify\n # by its lack of an activation function.\n if self.use_batch_norm and activation_fn:\n # Batch normalization uses weights as usual, but does NOT add a bias term. This is because \n # its calculations include gamma and beta variables that make the bias term unnecessary.\n # (See later in the notebook for more details.)\n weights = tf.Variable(initial_weights)\n linear_output = tf.matmul(layer_in, weights)\n\n # Apply batch normalization to the linear combination of the inputs and weights\n batch_normalized_output = tf.layers.batch_normalization(linear_output, training=self.is_training)\n\n # Now apply the activation function, *after* the normalization.\n return activation_fn(batch_normalized_output)\n else:\n # When not using batch normalization, create a standard layer that multiplies\n # the inputs and weights, adds a bias, and optionally passes the result \n # through an activation function. \n weights = tf.Variable(initial_weights)\n biases = tf.Variable(tf.zeros([initial_weights.shape[-1]]))\n linear_output = tf.add(tf.matmul(layer_in, weights), biases)\n return linear_output if not activation_fn else activation_fn(linear_output)\n\n def train(self, session, learning_rate, training_batches, batches_per_sample, save_model_as=None):\n \"\"\"\n Trains the model on the MNIST training dataset.\n \n :param session: Session\n Used to run training graph operations.\n :param learning_rate: float\n Learning rate used during gradient descent.\n :param training_batches: int\n Number of batches to train.\n :param batches_per_sample: int\n How many batches to train before sampling the validation accuracy.\n :param save_model_as: string or None (default None)\n Name to use if you want to save the trained model.\n \"\"\"\n # This placeholder will store the target labels for each mini batch\n labels = tf.placeholder(tf.float32, [None, 10])\n\n # Define loss and optimizer\n cross_entropy = tf.reduce_mean(\n tf.nn.softmax_cross_entropy_with_logits(labels=labels, logits=self.output_layer))\n \n # Define operations for testing\n correct_prediction = tf.equal(tf.argmax(self.output_layer, 1), tf.argmax(labels, 1))\n accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n\n if self.use_batch_norm:\n # If we don't include the update ops as dependencies on the train step, the \n # tf.layers.batch_normalization layers won't update their population statistics,\n # which will cause the model to fail at inference time\n with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):\n train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)\n else:\n train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)\n \n # Train for the appropriate number of batches. (tqdm is only for a nice timing display)\n for i in tqdm.tqdm(range(training_batches)):\n # We use batches of 60 just because the original paper did. You can use any size batch you like.\n batch_xs, batch_ys = mnist.train.next_batch(60)\n session.run(train_step, feed_dict={self.input_layer: batch_xs, \n labels: batch_ys, \n self.is_training: True})\n \n # Periodically test accuracy against the 5k validation images and store it for plotting later.\n if i % batches_per_sample == 0:\n test_accuracy = session.run(accuracy, feed_dict={self.input_layer: mnist.validation.images,\n labels: mnist.validation.labels,\n self.is_training: False})\n self.training_accuracies.append(test_accuracy)\n\n # After training, report accuracy against test data\n test_accuracy = session.run(accuracy, feed_dict={self.input_layer: mnist.validation.images,\n labels: mnist.validation.labels,\n self.is_training: False})\n print('{}: After training, final accuracy on validation set = {}'.format(self.name, test_accuracy))\n\n # If you want to use this model later for inference instead of having to retrain it,\n # just construct it with the same parameters and then pass this file to the 'test' function\n if save_model_as:\n tf.train.Saver().save(session, save_model_as)\n\n def test(self, session, test_training_accuracy=False, include_individual_predictions=False, restore_from=None):\n \"\"\"\n Trains a trained model on the MNIST testing dataset.\n\n :param session: Session\n Used to run the testing graph operations.\n :param test_training_accuracy: bool (default False)\n If True, perform inference with batch normalization using batch mean and variance;\n if False, perform inference with batch normalization using estimated population mean and variance.\n Note: in real life, *always* perform inference using the population mean and variance.\n This parameter exists just to support demonstrating what happens if you don't.\n :param include_individual_predictions: bool (default True)\n This function always performs an accuracy test against the entire test set. But if this parameter\n is True, it performs an extra test, doing 200 predictions one at a time, and displays the results\n and accuracy.\n :param restore_from: string or None (default None)\n Name of a saved model if you want to test with previously saved weights.\n \"\"\"\n # This placeholder will store the true labels for each mini batch\n labels = tf.placeholder(tf.float32, [None, 10])\n\n # Define operations for testing\n correct_prediction = tf.equal(tf.argmax(self.output_layer, 1), tf.argmax(labels, 1))\n accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n\n # If provided, restore from a previously saved model\n if restore_from:\n tf.train.Saver().restore(session, restore_from)\n\n # Test against all of the MNIST test data\n test_accuracy = session.run(accuracy, feed_dict={self.input_layer: mnist.test.images,\n labels: mnist.test.labels,\n self.is_training: test_training_accuracy})\n print('-'*75)\n print('{}: Accuracy on full test set = {}'.format(self.name, test_accuracy))\n\n # If requested, perform tests predicting individual values rather than batches\n if include_individual_predictions:\n predictions = []\n correct = 0\n\n # Do 200 predictions, 1 at a time\n for i in range(200):\n # This is a normal prediction using an individual test case. However, notice\n # we pass `test_training_accuracy` to `feed_dict` as the value for `self.is_training`.\n # Remember that will tell it whether it should use the batch mean & variance or\n # the population estimates that were calucated while training the model.\n pred, corr = session.run([tf.arg_max(self.output_layer,1), accuracy],\n feed_dict={self.input_layer: [mnist.test.images[i]],\n labels: [mnist.test.labels[i]],\n self.is_training: test_training_accuracy})\n correct += corr\n\n predictions.append(pred[0])\n\n print(\"200 Predictions:\", predictions)\n print(\"Accuracy on 200 samples:\", correct/200)\n", "_____no_output_____" ] ], [ [ "There are quite a few comments in the code, so those should answer most of your questions. However, let's take a look at the most important lines.\n\nWe add batch normalization to layers inside the `fully_connected` function. Here are some important points about that code:\n1. Layers with batch normalization do not include a bias term.\n2. We use TensorFlow's [`tf.layers.batch_normalization`](https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization) function to handle the math. (We show lower-level ways to do this [later in the notebook](#implementation_2).)\n3. We tell `tf.layers.batch_normalization` whether or not the network is training. This is an important step we'll talk about later.\n4. We add the normalization **before** calling the activation function.\n\nIn addition to that code, the training step is wrapped in the following `with` statement:\n```python\nwith tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):\n```\nThis line actually works in conjunction with the `training` parameter we pass to `tf.layers.batch_normalization`. Without it, TensorFlow's batch normalization layer will not operate correctly during inference.\n\nFinally, whenever we train the network or perform inference, we use the `feed_dict` to set `self.is_training` to `True` or `False`, respectively, like in the following line:\n```python\nsession.run(train_step, feed_dict={self.input_layer: batch_xs, \n labels: batch_ys, \n self.is_training: True})\n```\nWe'll go into more details later, but next we want to show some experiments that use this code and test networks with and without batch normalization.", "_____no_output_____" ], [ "# Batch Normalization Demos<a id='demos'></a>\nThis section of the notebook trains various networks with and without batch normalization to demonstrate some of the benefits mentioned earlier. \n\nWe'd like to thank the author of this blog post [Implementing Batch Normalization in TensorFlow](http://r2rt.com/implementing-batch-normalization-in-tensorflow.html). That post provided the idea of - and some of the code for - plotting the differences in accuracy during training, along with the idea for comparing multiple networks using the same initial weights.", "_____no_output_____" ], [ "## Code to support testing\n\nThe following two functions support the demos we run in the notebook. \n\nThe first function, `plot_training_accuracies`, simply plots the values found in the `training_accuracies` lists of the `NeuralNet` objects passed to it. If you look at the `train` function in `NeuralNet`, you'll see it that while it's training the network, it periodically measures validation accuracy and stores the results in that list. It does that just to support these plots.\n\nThe second function, `train_and_test`, creates two neural nets - one with and one without batch normalization. It then trains them both and tests them, calling `plot_training_accuracies` to plot how their accuracies changed over the course of training. The really imporant thing about this function is that it initializes the starting weights for the networks _outside_ of the networks and then passes them in. This lets it train both networks from the exact same starting weights, which eliminates performance differences that might result from (un)lucky initial weights.", "_____no_output_____" ] ], [ [ "def plot_training_accuracies(*args, **kwargs):\n \"\"\"\n Displays a plot of the accuracies calculated during training to demonstrate\n how many iterations it took for the model(s) to converge.\n \n :param args: One or more NeuralNet objects\n You can supply any number of NeuralNet objects as unnamed arguments \n and this will display their training accuracies. Be sure to call `train` \n the NeuralNets before calling this function.\n :param kwargs: \n You can supply any named parameters here, but `batches_per_sample` is the only\n one we look for. It should match the `batches_per_sample` value you passed\n to the `train` function.\n \"\"\"\n fig, ax = plt.subplots()\n\n batches_per_sample = kwargs['batches_per_sample']\n \n for nn in args:\n ax.plot(range(0,len(nn.training_accuracies)*batches_per_sample,batches_per_sample),\n nn.training_accuracies, label=nn.name)\n ax.set_xlabel('Training steps')\n ax.set_ylabel('Accuracy')\n ax.set_title('Validation Accuracy During Training')\n ax.legend(loc=4)\n ax.set_ylim([0,1])\n plt.yticks(np.arange(0, 1.1, 0.1))\n plt.grid(True)\n plt.show()\n\ndef train_and_test(use_bad_weights, learning_rate, activation_fn, training_batches=50000, batches_per_sample=500):\n \"\"\"\n Creates two networks, one with and one without batch normalization, then trains them\n with identical starting weights, layers, batches, etc. Finally tests and plots their accuracies.\n \n :param use_bad_weights: bool\n If True, initialize the weights of both networks to wildly inappropriate weights;\n if False, use reasonable starting weights.\n :param learning_rate: float\n Learning rate used during gradient descent.\n :param activation_fn: Callable\n The function used for the output of each hidden layer. The network will use the same\n activation function on every hidden layer and no activate function on the output layer.\n e.g. Pass tf.nn.relu to use ReLU activations on your hidden layers.\n :param training_batches: (default 50000)\n Number of batches to train.\n :param batches_per_sample: (default 500)\n How many batches to train before sampling the validation accuracy.\n \"\"\"\n # Use identical starting weights for each network to eliminate differences in\n # weight initialization as a cause for differences seen in training performance\n #\n # Note: The networks will use these weights to define the number of and shapes of\n # its layers. The original batch normalization paper used 3 hidden layers\n # with 100 nodes in each, followed by a 10 node output layer. These values\n # build such a network, but feel free to experiment with different choices.\n # However, the input size should always be 784 and the final output should be 10.\n if use_bad_weights:\n # These weights should be horrible because they have such a large standard deviation\n weights = [np.random.normal(size=(784,100), scale=5.0).astype(np.float32),\n np.random.normal(size=(100,100), scale=5.0).astype(np.float32),\n np.random.normal(size=(100,100), scale=5.0).astype(np.float32),\n np.random.normal(size=(100,10), scale=5.0).astype(np.float32)\n ]\n else:\n # These weights should be good because they have such a small standard deviation\n weights = [np.random.normal(size=(784,100), scale=0.05).astype(np.float32),\n np.random.normal(size=(100,100), scale=0.05).astype(np.float32),\n np.random.normal(size=(100,100), scale=0.05).astype(np.float32),\n np.random.normal(size=(100,10), scale=0.05).astype(np.float32)\n ]\n\n # Just to make sure the TensorFlow's default graph is empty before we start another\n # test, because we don't bother using different graphs or scoping and naming \n # elements carefully in this sample code.\n tf.reset_default_graph()\n\n # build two versions of same network, 1 without and 1 with batch normalization\n nn = NeuralNet(weights, activation_fn, False)\n bn = NeuralNet(weights, activation_fn, True)\n \n # train and test the two models\n with tf.Session() as sess:\n tf.global_variables_initializer().run()\n\n nn.train(sess, learning_rate, training_batches, batches_per_sample)\n bn.train(sess, learning_rate, training_batches, batches_per_sample)\n \n nn.test(sess)\n bn.test(sess)\n \n # Display a graph of how validation accuracies changed during training\n # so we can compare how the models trained and when they converged\n plot_training_accuracies(nn, bn, batches_per_sample=batches_per_sample)\n", "_____no_output_____" ] ], [ [ "## Comparisons between identical networks, with and without batch normalization\n\nThe next series of cells train networks with various settings to show the differences with and without batch normalization. They are meant to clearly demonstrate the effects of batch normalization. We include a deeper discussion of batch normalization later in the notebook.", "_____no_output_____" ], [ "**The following creates two networks using a ReLU activation function, a learning rate of 0.01, and reasonable starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(False, 0.01, tf.nn.relu)", "100%|██████████| 50000/50000 [00:42<00:00, 1183.34it/s]\n" ] ], [ [ "As expected, both networks train well and eventually reach similar test accuracies. However, notice that the model with batch normalization converges slightly faster than the other network, reaching accuracies over 90% almost immediately and nearing its max acuracy in 10 or 15 thousand iterations. The other network takes about 3 thousand iterations to reach 90% and doesn't near its best accuracy until 30 thousand or more iterations.\n\nIf you look at the raw speed, you can see that without batch normalization we were computing over 1100 batches per second, whereas with batch normalization that goes down to just over 500. However, batch normalization allows us to perform fewer iterations and converge in less time over all. (We only trained for 50 thousand batches here so we could plot the comparison.)", "_____no_output_____" ], [ "**The following creates two networks with the same hyperparameters used in the previous example, but only trains for 2000 iterations.**", "_____no_output_____" ] ], [ [ "train_and_test(False, 0.01, tf.nn.relu, 2000, 50)", "100%|██████████| 2000/2000 [00:01<00:00, 1069.17it/s]\n" ] ], [ [ "As you can see, using batch normalization produces a model with over 95% accuracy in only 2000 batches, and it was above 90% at somewhere around 500 batches. Without batch normalization, the model takes 1750 iterations just to hit 80% – the network with batch normalization hits that mark after around 200 iterations! (Note: if you run the code yourself, you'll see slightly different results each time because the starting weights - while the same for each model - are different for each run.)\n\nIn the above example, you should also notice that the networks trained fewer batches per second then what you saw in the previous example. That's because much of the time we're tracking is actually spent periodically performing inference to collect data for the plots. In this example we perform that inference every 50 batches instead of every 500, so generating the plot for this example requires 10 times the overhead for the same 2000 iterations.", "_____no_output_____" ], [ "**The following creates two networks using a sigmoid activation function, a learning rate of 0.01, and reasonable starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(False, 0.01, tf.nn.sigmoid)", "100%|██████████| 50000/50000 [00:43<00:00, 1153.97it/s]\n" ] ], [ [ "With the number of layers we're using and this small learning rate, using a sigmoid activation function takes a long time to start learning. It eventually starts making progress, but it took over 45 thousand batches just to get over 80% accuracy. Using batch normalization gets to 90% in around one thousand batches. ", "_____no_output_____" ], [ "**The following creates two networks using a ReLU activation function, a learning rate of 1, and reasonable starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(False, 1, tf.nn.relu)", "100%|██████████| 50000/50000 [00:35<00:00, 1397.55it/s]\n" ] ], [ [ "Now we're using ReLUs again, but with a larger learning rate. The plot shows how training started out pretty normally, with the network with batch normalization starting out faster than the other. But the higher learning rate bounces the accuracy around a bit more, and at some point the accuracy in the network without batch normalization just completely crashes. It's likely that too many ReLUs died off at this point because of the high learning rate.\n\nThe next cell shows the same test again. The network with batch normalization performs the same way, and the other suffers from the same problem again, but it manages to train longer before it happens.", "_____no_output_____" ] ], [ [ "train_and_test(False, 1, tf.nn.relu)", "100%|██████████| 50000/50000 [00:36<00:00, 1379.92it/s]\n" ] ], [ [ "In both of the previous examples, the network with batch normalization manages to gets over 98% accuracy, and get near that result almost immediately. The higher learning rate allows the network to train extremely fast.", "_____no_output_____" ], [ "**The following creates two networks using a sigmoid activation function, a learning rate of 1, and reasonable starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(False, 1, tf.nn.sigmoid)", "100%|██████████| 50000/50000 [00:36<00:00, 1382.38it/s]\n" ] ], [ [ "In this example, we switched to a sigmoid activation function. It appears to hande the higher learning rate well, with both networks achieving high accuracy.\n\nThe cell below shows a similar pair of networks trained for only 2000 iterations.", "_____no_output_____" ] ], [ [ "train_and_test(False, 1, tf.nn.sigmoid, 2000, 50)", "100%|██████████| 2000/2000 [00:01<00:00, 1167.28it/s]\n" ] ], [ [ "As you can see, even though these parameters work well for both networks, the one with batch normalization gets over 90% in 400 or so batches, whereas the other takes over 1700. When training larger networks, these sorts of differences become more pronounced.", "_____no_output_____" ], [ "**The following creates two networks using a ReLU activation function, a learning rate of 2, and reasonable starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(False, 2, tf.nn.relu)", "100%|██████████| 50000/50000 [00:35<00:00, 1412.09it/s]\n" ] ], [ [ "With this very large learning rate, the network with batch normalization trains fine and almost immediately manages 98% accuracy. However, the network without normalization doesn't learn at all.", "_____no_output_____" ], [ "**The following creates two networks using a sigmoid activation function, a learning rate of 2, and reasonable starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(False, 2, tf.nn.sigmoid)", "100%|██████████| 50000/50000 [00:35<00:00, 1395.37it/s]\n" ] ], [ [ "Once again, using a sigmoid activation function with the larger learning rate works well both with and without batch normalization.\n\nHowever, look at the plot below where we train models with the same parameters but only 2000 iterations. As usual, batch normalization lets it train faster. ", "_____no_output_____" ] ], [ [ "train_and_test(False, 2, tf.nn.sigmoid, 2000, 50)", "100%|██████████| 2000/2000 [00:01<00:00, 1170.27it/s]\n" ] ], [ [ "In the rest of the examples, we use really bad starting weights. That is, normally we would use very small values close to zero. However, in these examples we choose random values with a standard deviation of 5. If you were really training a neural network, you would **not** want to do this. But these examples demonstrate how batch normalization makes your network much more resilient. ", "_____no_output_____" ], [ "**The following creates two networks using a ReLU activation function, a learning rate of 0.01, and bad starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(True, 0.01, tf.nn.relu)", "100%|██████████| 50000/50000 [00:43<00:00, 1147.21it/s]\n" ] ], [ [ "As the plot shows, without batch normalization the network never learns anything at all. But with batch normalization, it actually learns pretty well and gets to almost 80% accuracy. The starting weights obviously hurt the network, but you can see how well batch normalization does in overcoming them. ", "_____no_output_____" ], [ "**The following creates two networks using a sigmoid activation function, a learning rate of 0.01, and bad starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(True, 0.01, tf.nn.sigmoid)", "100%|██████████| 50000/50000 [00:45<00:00, 1108.50it/s]\n" ] ], [ [ "Using a sigmoid activation function works better than the ReLU in the previous example, but without batch normalization it would take a tremendously long time to train the network, if it ever trained at all. ", "_____no_output_____" ], [ "**The following creates two networks using a ReLU activation function, a learning rate of 1, and bad starting weights.**<a id=\"successful_example_lr_1\"></a>", "_____no_output_____" ] ], [ [ "train_and_test(True, 1, tf.nn.relu)", "100%|██████████| 50000/50000 [00:38<00:00, 1313.14it/s]\n" ] ], [ [ "The higher learning rate used here allows the network with batch normalization to surpass 90% in about 30 thousand batches. The network without it never gets anywhere.", "_____no_output_____" ], [ "**The following creates two networks using a sigmoid activation function, a learning rate of 1, and bad starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(True, 1, tf.nn.sigmoid)", "100%|██████████| 50000/50000 [00:35<00:00, 1409.45it/s]\n" ] ], [ [ "Using sigmoid works better than ReLUs for this higher learning rate. However, you can see that without batch normalization, the network takes a long time tro train, bounces around a lot, and spends a long time stuck at 90%. The network with batch normalization trains much more quickly, seems to be more stable, and achieves a higher accuracy.", "_____no_output_____" ], [ "**The following creates two networks using a ReLU activation function, a learning rate of 2, and bad starting weights.**<a id=\"successful_example_lr_2\"></a>", "_____no_output_____" ] ], [ [ "train_and_test(True, 2, tf.nn.relu)", "100%|██████████| 50000/50000 [00:35<00:00, 1392.83it/s]\n" ] ], [ [ "We've already seen that ReLUs do not do as well as sigmoids with higher learning rates, and here we are using an extremely high rate. As expected, without batch normalization the network doesn't learn at all. But with batch normalization, it eventually achieves 90% accuracy. Notice, though, how its accuracy bounces around wildly during training - that's because the learning rate is really much too high, so the fact that this worked at all is a bit of luck.", "_____no_output_____" ], [ "**The following creates two networks using a sigmoid activation function, a learning rate of 2, and bad starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(True, 2, tf.nn.sigmoid)", "100%|██████████| 50000/50000 [00:35<00:00, 1401.19it/s]\n" ] ], [ [ "In this case, the network with batch normalization trained faster and reached a higher accuracy. Meanwhile, the high learning rate makes the network without normalization bounce around erratically and have trouble getting past 90%.", "_____no_output_____" ], [ "### Full Disclosure: Batch Normalization Doesn't Fix Everything\n\nBatch normalization isn't magic and it doesn't work every time. Weights are still randomly initialized and batches are chosen at random during training, so you never know exactly how training will go. Even for these tests, where we use the same initial weights for both networks, we still get _different_ weights each time we run.\n\nThis section includes two examples that show runs when batch normalization did not help at all.\n\n**The following creates two networks using a ReLU activation function, a learning rate of 1, and bad starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(True, 1, tf.nn.relu)", "100%|██████████| 50000/50000 [00:36<00:00, 1386.17it/s]\n" ] ], [ [ "When we used these same parameters [earlier](#successful_example_lr_1), we saw the network with batch normalization reach 92% validation accuracy. This time we used different starting weights, initialized using the same standard deviation as before, and the network doesn't learn at all. (Remember, an accuracy around 10% is what the network gets if it just guesses the same value all the time.)\n\n**The following creates two networks using a ReLU activation function, a learning rate of 2, and bad starting weights.**", "_____no_output_____" ] ], [ [ "train_and_test(True, 2, tf.nn.relu)", "100%|██████████| 50000/50000 [00:35<00:00, 1398.39it/s]\n" ] ], [ [ "When we trained with these parameters and batch normalization [earlier](#successful_example_lr_2), we reached 90% validation accuracy. However, this time the network _almost_ starts to make some progress in the beginning, but it quickly breaks down and stops learning. \n\n**Note:** Both of the above examples use *extremely* bad starting weights, along with learning rates that are too high. While we've shown batch normalization _can_ overcome bad values, we don't mean to encourage actually using them. The examples in this notebook are meant to show that batch normalization can help your networks train better. But these last two examples should remind you that you still want to try to use good network design choices and reasonable starting weights. It should also remind you that the results of each attempt to train a network are a bit random, even when using otherwise identical architectures.", "_____no_output_____" ], [ "# Batch Normalization: A Detailed Look<a id='implementation_2'></a>", "_____no_output_____" ], [ "The layer created by `tf.layers.batch_normalization` handles all the details of implementing batch normalization. Many students will be fine just using that and won't care about what's happening at the lower levels. However, some students may want to explore the details, so here is a short explanation of what's really happening, starting with the equations you're likely to come across if you ever read about batch normalization. ", "_____no_output_____" ], [ "In order to normalize the values, we first need to find the average value for the batch. If you look at the code, you can see that this is not the average value of the batch _inputs_, but the average value coming _out_ of any particular layer before we pass it through its non-linear activation function and then feed it as an input to the _next_ layer.\n\nWe represent the average as $\\mu_B$, which is simply the sum of all of the values $x_i$ divided by the number of values, $m$ \n\n$$\n\\mu_B \\leftarrow \\frac{1}{m}\\sum_{i=1}^m x_i\n$$\n\nWe then need to calculate the variance, or mean squared deviation, represented as $\\sigma_{B}^{2}$. If you aren't familiar with statistics, that simply means for each value $x_i$, we subtract the average value (calculated earlier as $\\mu_B$), which gives us what's called the \"deviation\" for that value. We square the result to get the squared deviation. Sum up the results of doing that for each of the values, then divide by the number of values, again $m$, to get the average, or mean, squared deviation.\n\n$$\n\\sigma_{B}^{2} \\leftarrow \\frac{1}{m}\\sum_{i=1}^m (x_i - \\mu_B)^2\n$$\n\nOnce we have the mean and variance, we can use them to normalize the values with the following equation. For each value, it subtracts the mean and divides by the (almost) standard deviation. (You've probably heard of standard deviation many times, but if you have not studied statistics you might not know that the standard deviation is actually the square root of the mean squared deviation.)\n\n$$\n\\hat{x_i} \\leftarrow \\frac{x_i - \\mu_B}{\\sqrt{\\sigma_{B}^{2} + \\epsilon}}\n$$\n\nAbove, we said \"(almost) standard deviation\". That's because the real standard deviation for the batch is calculated by $\\sqrt{\\sigma_{B}^{2}}$, but the above formula adds the term epsilon, $\\epsilon$, before taking the square root. The epsilon can be any small, positive constant - in our code we use the value `0.001`. It is there partially to make sure we don't try to divide by zero, but it also acts to increase the variance slightly for each batch. \n\nWhy increase the variance? Statistically, this makes sense because even though we are normalizing one batch at a time, we are also trying to estimate the population distribution – the total training set, which itself an estimate of the larger population of inputs your network wants to handle. The variance of a population is higher than the variance for any sample taken from that population, so increasing the variance a little bit for each batch helps take that into account. \n\nAt this point, we have a normalized value, represented as $\\hat{x_i}$. But rather than use it directly, we multiply it by a gamma value, $\\gamma$, and then add a beta value, $\\beta$. Both $\\gamma$ and $\\beta$ are learnable parameters of the network and serve to scale and shift the normalized value, respectively. Because they are learnable just like weights, they give your network some extra knobs to tweak during training to help it learn the function it is trying to approximate. \n\n$$\ny_i \\leftarrow \\gamma \\hat{x_i} + \\beta\n$$\n\nWe now have the final batch-normalized output of our layer, which we would then pass to a non-linear activation function like sigmoid, tanh, ReLU, Leaky ReLU, etc. In the original batch normalization paper (linked in the beginning of this notebook), they mention that there might be cases when you'd want to perform the batch normalization _after_ the non-linearity instead of before, but it is difficult to find any uses like that in practice.\n\nIn `NeuralNet`'s implementation of `fully_connected`, all of this math is hidden inside the following line, where `linear_output` serves as the $x_i$ from the equations:\n```python\nbatch_normalized_output = tf.layers.batch_normalization(linear_output, training=self.is_training)\n```\nThe next section shows you how to implement the math directly. ", "_____no_output_____" ], [ "### Batch normalization without the `tf.layers` package\n\nOur implementation of batch normalization in `NeuralNet` uses the high-level abstraction [tf.layers.batch_normalization](https://www.tensorflow.org/api_docs/python/tf/layers/batch_normalization), found in TensorFlow's [`tf.layers`](https://www.tensorflow.org/api_docs/python/tf/layers) package.\n\nHowever, if you would like to implement batch normalization at a lower level, the following code shows you how.\nIt uses [tf.nn.batch_normalization](https://www.tensorflow.org/api_docs/python/tf/nn/batch_normalization) from TensorFlow's [neural net (nn)](https://www.tensorflow.org/api_docs/python/tf/nn) package.\n\n**1)** You can replace the `fully_connected` function in the `NeuralNet` class with the below code and everything in `NeuralNet` will still work like it did before.", "_____no_output_____" ] ], [ [ "def fully_connected(self, layer_in, initial_weights, activation_fn=None):\n \"\"\"\n Creates a standard, fully connected layer. Its number of inputs and outputs will be\n defined by the shape of `initial_weights`, and its starting weight values will be\n taken directly from that same parameter. If `self.use_batch_norm` is True, this\n layer will include batch normalization, otherwise it will not. \n \n :param layer_in: Tensor\n The Tensor that feeds into this layer. It's either the input to the network or the output\n of a previous layer.\n :param initial_weights: NumPy array or Tensor\n Initial values for this layer's weights. The shape defines the number of nodes in the layer.\n e.g. Passing in 3 matrix of shape (784, 256) would create a layer with 784 inputs and 256 \n outputs. \n :param activation_fn: Callable or None (default None)\n The non-linearity used for the output of the layer. If None, this layer will not include \n batch normalization, regardless of the value of `self.use_batch_norm`. \n e.g. Pass tf.nn.relu to use ReLU activations on your hidden layers.\n \"\"\"\n if self.use_batch_norm and activation_fn:\n # Batch normalization uses weights as usual, but does NOT add a bias term. This is because \n # its calculations include gamma and beta variables that make the bias term unnecessary.\n weights = tf.Variable(initial_weights)\n linear_output = tf.matmul(layer_in, weights)\n\n num_out_nodes = initial_weights.shape[-1]\n\n # Batch normalization adds additional trainable variables: \n # gamma (for scaling) and beta (for shifting).\n gamma = tf.Variable(tf.ones([num_out_nodes]))\n beta = tf.Variable(tf.zeros([num_out_nodes]))\n\n # These variables will store the mean and variance for this layer over the entire training set,\n # which we assume represents the general population distribution.\n # By setting `trainable=False`, we tell TensorFlow not to modify these variables during\n # back propagation. Instead, we will assign values to these variables ourselves. \n pop_mean = tf.Variable(tf.zeros([num_out_nodes]), trainable=False)\n pop_variance = tf.Variable(tf.ones([num_out_nodes]), trainable=False)\n\n # Batch normalization requires a small constant epsilon, used to ensure we don't divide by zero.\n # This is the default value TensorFlow uses.\n epsilon = 1e-3\n\n def batch_norm_training():\n # Calculate the mean and variance for the data coming out of this layer's linear-combination step.\n # The [0] defines an array of axes to calculate over.\n batch_mean, batch_variance = tf.nn.moments(linear_output, [0])\n\n # Calculate a moving average of the training data's mean and variance while training.\n # These will be used during inference.\n # Decay should be some number less than 1. tf.layers.batch_normalization uses the parameter\n # \"momentum\" to accomplish this and defaults it to 0.99\n decay = 0.99\n train_mean = tf.assign(pop_mean, pop_mean * decay + batch_mean * (1 - decay))\n train_variance = tf.assign(pop_variance, pop_variance * decay + batch_variance * (1 - decay))\n\n # The 'tf.control_dependencies' context tells TensorFlow it must calculate 'train_mean' \n # and 'train_variance' before it calculates the 'tf.nn.batch_normalization' layer.\n # This is necessary because the those two operations are not actually in the graph\n # connecting the linear_output and batch_normalization layers, \n # so TensorFlow would otherwise just skip them.\n with tf.control_dependencies([train_mean, train_variance]):\n return tf.nn.batch_normalization(linear_output, batch_mean, batch_variance, beta, gamma, epsilon)\n \n def batch_norm_inference():\n # During inference, use the our estimated population mean and variance to normalize the layer\n return tf.nn.batch_normalization(linear_output, pop_mean, pop_variance, beta, gamma, epsilon)\n\n # Use `tf.cond` as a sort of if-check. When self.is_training is True, TensorFlow will execute \n # the operation returned from `batch_norm_training`; otherwise it will execute the graph\n # operation returned from `batch_norm_inference`.\n batch_normalized_output = tf.cond(self.is_training, batch_norm_training, batch_norm_inference)\n \n # Pass the batch-normalized layer output through the activation function.\n # The literature states there may be cases where you want to perform the batch normalization *after*\n # the activation function, but it is difficult to find any uses of that in practice.\n return activation_fn(batch_normalized_output)\n else:\n # When not using batch normalization, create a standard layer that multiplies\n # the inputs and weights, adds a bias, and optionally passes the result \n # through an activation function. \n weights = tf.Variable(initial_weights)\n biases = tf.Variable(tf.zeros([initial_weights.shape[-1]]))\n linear_output = tf.add(tf.matmul(layer_in, weights), biases)\n return linear_output if not activation_fn else activation_fn(linear_output)\n", "_____no_output_____" ] ], [ [ "This version of `fully_connected` is much longer than the original, but once again has extensive comments to help you understand it. Here are some important points:\n\n1. It explicitly creates variables to store gamma, beta, and the population mean and variance. These were all handled for us in the previous version of the function.\n2. It initializes gamma to one and beta to zero, so they start out having no effect in this calculation: $y_i \\leftarrow \\gamma \\hat{x_i} + \\beta$. However, during training the network learns the best values for these variables using back propagation, just like networks normally do with weights.\n3. Unlike gamma and beta, the variables for population mean and variance are marked as untrainable. That tells TensorFlow not to modify them during back propagation. Instead, the lines that call `tf.assign` are used to update these variables directly.\n4. TensorFlow won't automatically run the `tf.assign` operations during training because it only evaluates operations that are required based on the connections it finds in the graph. To get around that, we add this line: `with tf.control_dependencies([train_mean, train_variance]):` before we run the normalization operation. This tells TensorFlow it needs to run those operations before running anything inside the `with` block. \n5. The actual normalization math is still mostly hidden from us, this time using [`tf.nn.batch_normalization`](https://www.tensorflow.org/api_docs/python/tf/nn/batch_normalization).\n5. `tf.nn.batch_normalization` does not have a `training` parameter like `tf.layers.batch_normalization` did. However, we still need to handle training and inference differently, so we run different code in each case using the [`tf.cond`](https://www.tensorflow.org/api_docs/python/tf/cond) operation.\n6. We use the [`tf.nn.moments`](https://www.tensorflow.org/api_docs/python/tf/nn/moments) function to calculate the batch mean and variance.", "_____no_output_____" ], [ "**2)** The current version of the `train` function in `NeuralNet` will work fine with this new version of `fully_connected`. However, it uses these lines to ensure population statistics are updated when using batch normalization: \n```python\nif self.use_batch_norm:\n with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):\n train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)\nelse:\n train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)\n```\nOur new version of `fully_connected` handles updating the population statistics directly. That means you can also simplify your code by replacing the above `if`/`else` condition with just this line:\n```python\ntrain_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(cross_entropy)\n```", "_____no_output_____" ], [ "**3)** And just in case you want to implement every detail from scratch, you can replace this line in `batch_norm_training`:\n\n```python\nreturn tf.nn.batch_normalization(linear_output, batch_mean, batch_variance, beta, gamma, epsilon)\n```\nwith these lines:\n```python\nnormalized_linear_output = (linear_output - batch_mean) / tf.sqrt(batch_variance + epsilon)\nreturn gamma * normalized_linear_output + beta\n```\nAnd replace this line in `batch_norm_inference`:\n```python\nreturn tf.nn.batch_normalization(linear_output, pop_mean, pop_variance, beta, gamma, epsilon)\n```\nwith these lines:\n```python\nnormalized_linear_output = (linear_output - pop_mean) / tf.sqrt(pop_variance + epsilon)\nreturn gamma * normalized_linear_output + beta\n```\n\nAs you can see in each of the above substitutions, the two lines of replacement code simply implement the following two equations directly. The first line calculates the following equation, with `linear_output` representing $x_i$ and `normalized_linear_output` representing $\\hat{x_i}$: \n\n$$\n\\hat{x_i} \\leftarrow \\frac{x_i - \\mu_B}{\\sqrt{\\sigma_{B}^{2} + \\epsilon}}\n$$\n\nAnd the second line is a direct translation of the following equation:\n\n$$\ny_i \\leftarrow \\gamma \\hat{x_i} + \\beta\n$$\n\nWe still use the `tf.nn.moments` operation to implement the other two equations from earlier – the ones that calculate the batch mean and variance used in the normalization step. If you really wanted to do everything from scratch, you could replace that line, too, but we'll leave that to you. \n\n## Why the difference between training and inference?\n\nIn the original function that uses `tf.layers.batch_normalization`, we tell the layer whether or not the network is training by passing a value for its `training` parameter, like so:\n```python\nbatch_normalized_output = tf.layers.batch_normalization(linear_output, training=self.is_training)\n```\nAnd that forces us to provide a value for `self.is_training` in our `feed_dict`, like we do in this example from `NeuralNet`'s `train` function:\n```python\nsession.run(train_step, feed_dict={self.input_layer: batch_xs, \n labels: batch_ys, \n self.is_training: True})\n```\nIf you looked at the [low level implementation](#low_level_code), you probably noticed that, just like with `tf.layers.batch_normalization`, we need to do slightly different things during training and inference. But why is that?\n\nFirst, let's look at what happens when we don't. The following function is similar to `train_and_test` from earlier, but this time we are only testing one network and instead of plotting its accuracy, we perform 200 predictions on test inputs, 1 input at at time. We can use the `test_training_accuracy` parameter to test the network in training or inference modes (the equivalent of passing `True` or `False` to the `feed_dict` for `is_training`).", "_____no_output_____" ] ], [ [ "def batch_norm_test(test_training_accuracy):\n \"\"\"\n :param test_training_accuracy: bool\n If True, perform inference with batch normalization using batch mean and variance;\n if False, perform inference with batch normalization using estimated population mean and variance.\n \"\"\"\n\n weights = [np.random.normal(size=(784,100), scale=0.05).astype(np.float32),\n np.random.normal(size=(100,100), scale=0.05).astype(np.float32),\n np.random.normal(size=(100,100), scale=0.05).astype(np.float32),\n np.random.normal(size=(100,10), scale=0.05).astype(np.float32)\n ]\n\n tf.reset_default_graph()\n\n # Train the model\n bn = NeuralNet(weights, tf.nn.relu, True)\n \n # First train the network\n with tf.Session() as sess:\n tf.global_variables_initializer().run()\n\n bn.train(sess, 0.01, 2000, 2000)\n\n bn.test(sess, test_training_accuracy=test_training_accuracy, include_individual_predictions=True)", "_____no_output_____" ] ], [ [ "In the following cell, we pass `True` for `test_training_accuracy`, which performs the same batch normalization that we normally perform **during training**.", "_____no_output_____" ] ], [ [ "batch_norm_test(True)", "100%|██████████| 2000/2000 [00:03<00:00, 514.57it/s]\n" ] ], [ [ "As you can see, the network guessed the same value every time! But why? Because during training, a network with batch normalization adjusts the values at each layer based on the mean and variance **of that batch**. The \"batches\" we are using for these predictions have a single input each time, so their values _are_ the means, and their variances will always be 0. That means the network will normalize the values at any layer to zero. (Review the equations from before to see why a value that is equal to the mean would always normalize to zero.) So we end up with the same result for every input we give the network, because its the value the network produces when it applies its learned weights to zeros at every layer. \n\n**Note:** If you re-run that cell, you might get a different value from what we showed. That's because the specific weights the network learns will be different every time. But whatever value it is, it should be the same for all 200 predictions.\n\nTo overcome this problem, the network does not just normalize the batch at each layer. It also maintains an estimate of the mean and variance for the entire population. So when we perform inference, instead of letting it \"normalize\" all the values using their own means and variance, it uses the estimates of the population mean and variance that it calculated while training. \n\nSo in the following example, we pass `False` for `test_training_accuracy`, which tells the network that we it want to perform inference with the population statistics it calculates during training.", "_____no_output_____" ] ], [ [ "batch_norm_test(False)", "100%|██████████| 2000/2000 [00:03<00:00, 511.58it/s]\n" ] ], [ [ "As you can see, now that we're using the estimated population mean and variance, we get a 97% accuracy. That means it guessed correctly on 194 of the 200 samples – not too bad for something that trained in under 4 seconds. :)\n\n# Considerations for other network types\n\nThis notebook demonstrates batch normalization in a standard neural network with fully connected layers. You can also use batch normalization in other types of networks, but there are some special considerations.\n\n### ConvNets\n\nConvolution layers consist of multiple feature maps. (Remember, the depth of a convolutional layer refers to its number of feature maps.) And the weights for each feature map are shared across all the inputs that feed into the layer. Because of these differences, batch normalizaing convolutional layers requires batch/population mean and variance per feature map rather than per node in the layer.\n\nWhen using `tf.layers.batch_normalization`, be sure to pay attention to the order of your convolutionlal dimensions.\nSpecifically, you may want to set a different value for the `axis` parameter if your layers have their channels first instead of last. \n\nIn our low-level implementations, we used the following line to calculate the batch mean and variance:\n```python\nbatch_mean, batch_variance = tf.nn.moments(linear_output, [0])\n```\nIf we were dealing with a convolutional layer, we would calculate the mean and variance with a line like this instead:\n```python\nbatch_mean, batch_variance = tf.nn.moments(conv_layer, [0,1,2], keep_dims=False)\n```\nThe second parameter, `[0,1,2]`, tells TensorFlow to calculate the batch mean and variance over each feature map. (The three axes are the batch, height, and width.) And setting `keep_dims` to `False` tells `tf.nn.moments` not to return values with the same size as the inputs. Specifically, it ensures we get one mean/variance pair per feature map.\n\n### RNNs\n\nBatch normalization can work with recurrent neural networks, too, as shown in the 2016 paper [Recurrent Batch Normalization](https://arxiv.org/abs/1603.09025). It's a bit more work to implement, but basically involves calculating the means and variances per time step instead of per layer. You can find an example where someone extended `tf.nn.rnn_cell.RNNCell` to include batch normalization in [this GitHub repo](https://gist.github.com/spitis/27ab7d2a30bbaf5ef431b4a02194ac60).", "_____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", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown", "code", "markdown" ]

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

[ "MIT" ]

[ "MIT" ]