hexsha
stringlengths 40
40
| size
int64 6
14.9M
| ext
stringclasses 1
value | lang
stringclasses 1
value | max_stars_repo_path
stringlengths 6
260
| max_stars_repo_name
stringlengths 6
119
| max_stars_repo_head_hexsha
stringlengths 40
41
| max_stars_repo_licenses
sequence | max_stars_count
int64 1
191k
⌀ | max_stars_repo_stars_event_min_datetime
stringlengths 24
24
⌀ | max_stars_repo_stars_event_max_datetime
stringlengths 24
24
⌀ | max_issues_repo_path
stringlengths 6
260
| max_issues_repo_name
stringlengths 6
119
| max_issues_repo_head_hexsha
stringlengths 40
41
| max_issues_repo_licenses
sequence | max_issues_count
int64 1
67k
⌀ | max_issues_repo_issues_event_min_datetime
stringlengths 24
24
⌀ | max_issues_repo_issues_event_max_datetime
stringlengths 24
24
⌀ | max_forks_repo_path
stringlengths 6
260
| max_forks_repo_name
stringlengths 6
119
| max_forks_repo_head_hexsha
stringlengths 40
41
| max_forks_repo_licenses
sequence | max_forks_count
int64 1
105k
⌀ | max_forks_repo_forks_event_min_datetime
stringlengths 24
24
⌀ | max_forks_repo_forks_event_max_datetime
stringlengths 24
24
⌀ | avg_line_length
float64 2
1.04M
| max_line_length
int64 2
11.2M
| alphanum_fraction
float64 0
1
| cells
sequence | cell_types
sequence | cell_type_groups
sequence |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
ece7b2aa4c7d1b43c991a2f12cc583b2acb823f0 | 68,021 | ipynb | Jupyter Notebook | jupyter/pandas-tut/10-Reading and Writing Data.ipynb | Sesughter01/ds-march-univel | fbed9e39abf08f7ffdf01d491ce3d898fafaed12 | [
"MIT"
] | null | null | null | jupyter/pandas-tut/10-Reading and Writing Data.ipynb | Sesughter01/ds-march-univel | fbed9e39abf08f7ffdf01d491ce3d898fafaed12 | [
"MIT"
] | null | null | null | jupyter/pandas-tut/10-Reading and Writing Data.ipynb | Sesughter01/ds-march-univel | fbed9e39abf08f7ffdf01d491ce3d898fafaed12 | [
"MIT"
] | 2 | 2022-03-03T15:03:14.000Z | 2022-03-15T11:42:24.000Z | 28.798052 | 160 | 0.337543 | [
[
[
"# Tutorial 10: Data Reading and Writting",
"_____no_output_____"
]
],
[
[
"import pandas as pd \nimport numpy as np ",
"_____no_output_____"
],
[
"df=pd.read_table(\"DataSets/data.txt\")\ndf",
"_____no_output_____"
],
[
"df2=pd.read_table(\"DataSets/data2.txt\")\ndf2",
"_____no_output_____"
],
[
"df2=pd.read_table(\"Data/data2.txt\", sep=\",\")\ndf2",
"_____no_output_____"
],
[
"df=pd.read_table(\"Data/data2.txt\", sep=\",\")\ndf",
"_____no_output_____"
],
[
"df=pd.read_table(\"DataSets/data2.txt\",\n sep=\",\",\n names=['name', \"number\", \"sex\"])\ndf",
"_____no_output_____"
],
[
"df=pd.read_table(\"Data/data2.txt\",\n sep=\",\",\n header=None, \n names=[\"name\",\"score\",\"sex\"])\ndf",
"_____no_output_____"
],
[
"df=pd.read_table(\"Data/data2.txt\",\n sep=\",\",header=None, \n names=[\"name\",\"score\",\"sex\"],\n index_col=\"name\")\ndf",
"_____no_output_____"
],
[
"df2=pd.read_table(\"Data/data3.txt\",\n sep=\",\")\ndf2",
"_____no_output_____"
],
[
"df2=pd.read_table(\"Data/data3.txt\",\n sep=\",\",\n index_col=[\"lesson\",\"name\"])\ndf2",
"_____no_output_____"
],
[
"df3=pd.read_table(\"Data/data4.txt\",sep=\",\")\ndf3",
"_____no_output_____"
],
[
"df3=pd.read_table(\"Data/data4.txt\",\n sep=\",\", \n skiprows=[0,2])\ndf3",
"_____no_output_____"
],
[
"df3=pd.read_table(\"Data/data4.txt\",\n sep=\",\", \n skiprows=[0,2],\n usecols=[0,1])\ndf3",
"_____no_output_____"
],
[
"df3=pd.read_table(\"Data/data4.txt\",\n sep=\",\", \n skiprows=[0,2],\n usecols=[0,1],\n nrows=3)\ndf3",
"_____no_output_____"
]
],
[
[
"## Writing Data",
"_____no_output_____"
]
],
[
[
"df=pd.read_csv(\"DataSets/supermarket_sales - Sheet1.csv\")",
"_____no_output_____"
],
[
"mask = df[\"Gender\"] == \"Male\"\nmale_sales = df[mask]\n\nmask = df[\"Gender\"] == \"Female\"\nfemale_sales = df[mask]",
"_____no_output_____"
],
[
"##Write male and female sales individualy to csv\nmale_sales.to_csv(\"DataSets/male_sales.csv\")\nfemale_sales.to_csv(\"DataSets/female_sales.csv\")",
"_____no_output_____"
],
[
"df=pd.read_csv(\"Data/data.txt\",sep=\"\\t\")\ndf",
"_____no_output_____"
],
[
"df.to_csv(\"Data/new_data.csv\")",
"_____no_output_____"
],
[
"# Read excel",
"_____no_output_____"
],
[
"female_df = pd.read_excel(\"DataSets/m_f_sales.xlsx\", sheet_name = \"female_sales\")\nmale_df = pd.read_excel(\"DataSets/m_f_sales.xlsx\", sheet_name = \"male_sales\")",
"_____no_output_____"
],
[
"branch_a_mask = female_df[\"Branch\"] == \"A\"\nbranch_b_mask = female_df[\"Branch\"] == \"B\"\n\nbranch_a = female_df[branch_a_mask]\nbranch_b = female_df[branch_b_mask]",
"_____no_output_____"
],
[
"with pd.ExcelWriter('branches.xlsx', mode='w') as writer: \n \n branch_a.to_excel(writer, sheet_name='Branch A')\n branch_b.to_excel(writer, sheet_name='Branch B')",
"_____no_output_____"
],
[
"male_df",
"_____no_output_____"
],
[
"#Automate process getting all different unique Product lines in different sheets",
"_____no_output_____"
],
[
"female_df = pd.read_excel(\"DataSets/m_f_sales.xlsx\", sheet_name = \"female_sales\")\nmale_df = pd.read_excel(\"DataSets/m_f_sales.xlsx\", sheet_name = \"male_sales\")",
"_____no_output_____"
],
[
"# Get Unique Product lines",
"_____no_output_____"
],
[
"female_df[\"Product line\"].unique()",
"_____no_output_____"
],
[
"male_df[\"Product line\"].unique()",
"_____no_output_____"
],
[
"unique_products_lines = female_df[\"Product line\"].unique()\n\nfor prod_lin in unique_products_lines:\n \n print(prod_lin)",
"Health and beauty\nElectronic accessories\nHome and lifestyle\nFood and beverages\nFashion accessories\nSports and travel\n"
],
[
"unique_products_lines = female_df[\"Product line\"].unique()\n\nwith pd.ExcelWriter('prod_lines.xlsx', mode='w') as writer: \n \n for prod_lin_from_forloop in unique_products_lines:\n \n prod_line_mask = female_df[\"Product line\"] == prod_lin_from_forloop\n\n prod_line_df = female_df[prod_line_mask]\n prod_line_df.to_excel(writer, sheet_name=prod_lin_from_forloop)",
"_____no_output_____"
],
[
"female_df.describe()",
"_____no_output_____"
],
[
"male_df.describe()",
"_____no_output_____"
],
[
"female_df.describe(include=[\"O\"])",
"_____no_output_____"
],
[
"male_df.describe(include=[\"O\"])",
"_____no_output_____"
]
],
[
[
"Don't forget to follow us on our Tirendaz Academy YouTube channel http://youtube.com/c/tirendazakademi and Medium page (http://tirendazacademy.medium.com)",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown"
],
[
"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",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
]
] |
ece7b60108c6cb16545dd1ff2299fb6a86e8593b | 101,611 | ipynb | Jupyter Notebook | samples/shapes/train_shapes.ipynb | mksuns/maskrcnn | 8daae5c1f0d1897cfc3be91c39f4d129a5f86eeb | [
"MIT"
] | null | null | null | samples/shapes/train_shapes.ipynb | mksuns/maskrcnn | 8daae5c1f0d1897cfc3be91c39f4d129a5f86eeb | [
"MIT"
] | null | null | null | samples/shapes/train_shapes.ipynb | mksuns/maskrcnn | 8daae5c1f0d1897cfc3be91c39f4d129a5f86eeb | [
"MIT"
] | null | null | null | 97.985535 | 23,858 | 0.786322 | [
[
[
"# Mask R-CNN - Train on Shapes Dataset\n\n\nThis notebook shows how to train Mask R-CNN on your own dataset. To keep things simple we use a synthetic dataset of shapes (squares, triangles, and circles) which enables fast training. You'd still need a GPU, though, because the network backbone is a Resnet101, which would be too slow to train on a CPU. On a GPU, you can start to get okay-ish results in a few minutes, and good results in less than an hour.\n\nThe code of the *Shapes* dataset is included below. It generates images on the fly, so it doesn't require downloading any data. And it can generate images of any size, so we pick a small image size to train faster. ",
"_____no_output_____"
]
],
[
[
"import os\nimport sys\nimport random\nimport math\nimport re\nimport time\nimport numpy as np\nimport cv2\nimport matplotlib\nimport matplotlib.pyplot as plt\n\n# Root directory of the project\nROOT_DIR = os.path.abspath(\"../../\")\n\n# Import Mask RCNN\nsys.path.append(ROOT_DIR) # To find local version of the library\nfrom mrcnn.config import Config\nfrom mrcnn import utils\nimport mrcnn.model as modellib\nfrom mrcnn import visualize\nfrom mrcnn.model import log\n\n%matplotlib inline \n\n# Directory to save logs and trained model\nMODEL_DIR = os.path.join(ROOT_DIR, \"logs\")\n\n# Local path to trained weights file\nCOCO_MODEL_PATH = os.path.join(ROOT_DIR, \"mask_rcnn_coco.h5\")\n# Download COCO trained weights from Releases if needed\nif not os.path.exists(COCO_MODEL_PATH):\n utils.download_trained_weights(COCO_MODEL_PATH)",
"Using TensorFlow backend.\n"
]
],
[
[
"## Configurations",
"_____no_output_____"
]
],
[
[
"class ShapesConfig(Config):\n \"\"\"Configuration for training on the toy shapes dataset.\n Derives from the base Config class and overrides values specific\n to the toy shapes dataset.\n \"\"\"\n # Give the configuration a recognizable name\n NAME = \"shapes\"\n\n # Train on 1 GPU and 8 images per GPU. We can put multiple images on each\n # GPU because the images are small. Batch size is 8 (GPUs * images/GPU).\n GPU_COUNT = 1\n IMAGES_PER_GPU = 8\n\n # Number of classes (including background)\n NUM_CLASSES = 1 + 3 # background + 3 shapes\n\n # Use small images for faster training. Set the limits of the small side\n # the large side, and that determines the image shape.\n IMAGE_MIN_DIM = 128\n IMAGE_MAX_DIM = 128\n\n # Use smaller anchors because our image and objects are small\n RPN_ANCHOR_SCALES = (8, 16, 32, 64, 128) # anchor side in pixels\n\n # Reduce training ROIs per image because the images are small and have\n # few objects. Aim to allow ROI sampling to pick 33% positive ROIs.\n TRAIN_ROIS_PER_IMAGE = 32\n\n # Use a small epoch since the data is simple\n STEPS_PER_EPOCH = 100\n\n # use small validation steps since the epoch is small\n VALIDATION_STEPS = 5\n \nconfig = ShapesConfig()\nconfig.display()",
"\nConfigurations:\nBACKBONE_SHAPES [[32 32]\n [16 16]\n [ 8 8]\n [ 4 4]\n [ 2 2]]\nBACKBONE_STRIDES [4, 8, 16, 32, 64]\nBATCH_SIZE 8\nBBOX_STD_DEV [ 0.1 0.1 0.2 0.2]\nDETECTION_MAX_INSTANCES 100\nDETECTION_MIN_CONFIDENCE 0.5\nDETECTION_NMS_THRESHOLD 0.3\nGPU_COUNT 1\nIMAGES_PER_GPU 8\nIMAGE_MAX_DIM 128\nIMAGE_MIN_DIM 128\nIMAGE_PADDING True\nIMAGE_SHAPE [128 128 3]\nLEARNING_MOMENTUM 0.9\nLEARNING_RATE 0.002\nMASK_POOL_SIZE 14\nMASK_SHAPE [28, 28]\nMAX_GT_INSTANCES 100\nMEAN_PIXEL [ 123.7 116.8 103.9]\nMINI_MASK_SHAPE (56, 56)\nNAME SHAPES\nNUM_CLASSES 4\nPOOL_SIZE 7\nPOST_NMS_ROIS_INFERENCE 1000\nPOST_NMS_ROIS_TRAINING 2000\nROI_POSITIVE_RATIO 0.33\nRPN_ANCHOR_RATIOS [0.5, 1, 2]\nRPN_ANCHOR_SCALES (8, 16, 32, 64, 128)\nRPN_ANCHOR_STRIDE 2\nRPN_BBOX_STD_DEV [ 0.1 0.1 0.2 0.2]\nRPN_TRAIN_ANCHORS_PER_IMAGE 256\nSTEPS_PER_EPOCH 100\nTRAIN_ROIS_PER_IMAGE 32\nUSE_MINI_MASK True\nUSE_RPN_ROIS True\nVALIDATION_STEPS 50\nWEIGHT_DECAY 0.0001\n\n\n"
]
],
[
[
"## Notebook Preferences",
"_____no_output_____"
]
],
[
[
"def get_ax(rows=1, cols=1, size=8):\n \"\"\"Return a Matplotlib Axes array to be used in\n all visualizations in the notebook. Provide a\n central point to control graph sizes.\n \n Change the default size attribute to control the size\n of rendered images\n \"\"\"\n _, ax = plt.subplots(rows, cols, figsize=(size*cols, size*rows))\n return ax",
"_____no_output_____"
]
],
[
[
"## Dataset\n\nCreate a synthetic dataset\n\nExtend the Dataset class and add a method to load the shapes dataset, `load_shapes()`, and override the following methods:\n\n* load_image()\n* load_mask()\n* image_reference()",
"_____no_output_____"
]
],
[
[
"class ShapesDataset(utils.Dataset):\n \"\"\"Generates the shapes synthetic dataset. The dataset consists of simple\n shapes (triangles, squares, circles) placed randomly on a blank surface.\n The images are generated on the fly. No file access required.\n \"\"\"\n\n def load_shapes(self, count, height, width):\n \"\"\"Generate the requested number of synthetic images.\n count: number of images to generate.\n height, width: the size of the generated images.\n \"\"\"\n # Add classes\n self.add_class(\"shapes\", 1, \"square\")\n self.add_class(\"shapes\", 2, \"circle\")\n self.add_class(\"shapes\", 3, \"triangle\")\n\n # Add images\n # Generate random specifications of images (i.e. color and\n # list of shapes sizes and locations). This is more compact than\n # actual images. Images are generated on the fly in load_image().\n for i in range(count):\n bg_color, shapes = self.random_image(height, width)\n self.add_image(\"shapes\", image_id=i, path=None,\n width=width, height=height,\n bg_color=bg_color, shapes=shapes)\n\n def load_image(self, image_id):\n \"\"\"Generate an image from the specs of the given image ID.\n Typically this function loads the image from a file, but\n in this case it generates the image on the fly from the\n specs in image_info.\n \"\"\"\n info = self.image_info[image_id]\n bg_color = np.array(info['bg_color']).reshape([1, 1, 3])\n image = np.ones([info['height'], info['width'], 3], dtype=np.uint8)\n image = image * bg_color.astype(np.uint8)\n for shape, color, dims in info['shapes']:\n image = self.draw_shape(image, shape, dims, color)\n return image\n\n def image_reference(self, image_id):\n \"\"\"Return the shapes data of the image.\"\"\"\n info = self.image_info[image_id]\n if info[\"source\"] == \"shapes\":\n return info[\"shapes\"]\n else:\n super(self.__class__).image_reference(self, image_id)\n\n def load_mask(self, image_id):\n \"\"\"Generate instance masks for shapes of the given image ID.\n \"\"\"\n info = self.image_info[image_id]\n shapes = info['shapes']\n count = len(shapes)\n mask = np.zeros([info['height'], info['width'], count], dtype=np.uint8)\n for i, (shape, _, dims) in enumerate(info['shapes']):\n mask[:, :, i:i+1] = self.draw_shape(mask[:, :, i:i+1].copy(),\n shape, dims, 1)\n # Handle occlusions\n occlusion = np.logical_not(mask[:, :, -1]).astype(np.uint8)\n for i in range(count-2, -1, -1):\n mask[:, :, i] = mask[:, :, i] * occlusion\n occlusion = np.logical_and(occlusion, np.logical_not(mask[:, :, i]))\n # Map class names to class IDs.\n class_ids = np.array([self.class_names.index(s[0]) for s in shapes])\n return mask.astype(np.bool), class_ids.astype(np.int32)\n\n def draw_shape(self, image, shape, dims, color):\n \"\"\"Draws a shape from the given specs.\"\"\"\n # Get the center x, y and the size s\n x, y, s = dims\n if shape == 'square':\n cv2.rectangle(image, (x-s, y-s), (x+s, y+s), color, -1)\n elif shape == \"circle\":\n cv2.circle(image, (x, y), s, color, -1)\n elif shape == \"triangle\":\n points = np.array([[(x, y-s),\n (x-s/math.sin(math.radians(60)), y+s),\n (x+s/math.sin(math.radians(60)), y+s),\n ]], dtype=np.int32)\n cv2.fillPoly(image, points, color)\n return image\n\n def random_shape(self, height, width):\n \"\"\"Generates specifications of a random shape that lies within\n the given height and width boundaries.\n Returns a tuple of three valus:\n * The shape name (square, circle, ...)\n * Shape color: a tuple of 3 values, RGB.\n * Shape dimensions: A tuple of values that define the shape size\n and location. Differs per shape type.\n \"\"\"\n # Shape\n shape = random.choice([\"square\", \"circle\", \"triangle\"])\n # Color\n color = tuple([random.randint(0, 255) for _ in range(3)])\n # Center x, y\n buffer = 20\n y = random.randint(buffer, height - buffer - 1)\n x = random.randint(buffer, width - buffer - 1)\n # Size\n s = random.randint(buffer, height//4)\n return shape, color, (x, y, s)\n\n def random_image(self, height, width):\n \"\"\"Creates random specifications of an image with multiple shapes.\n Returns the background color of the image and a list of shape\n specifications that can be used to draw the image.\n \"\"\"\n # Pick random background color\n bg_color = np.array([random.randint(0, 255) for _ in range(3)])\n # Generate a few random shapes and record their\n # bounding boxes\n shapes = []\n boxes = []\n N = random.randint(1, 4)\n for _ in range(N):\n shape, color, dims = self.random_shape(height, width)\n shapes.append((shape, color, dims))\n x, y, s = dims\n boxes.append([y-s, x-s, y+s, x+s])\n # Apply non-max suppression wit 0.3 threshold to avoid\n # shapes covering each other\n keep_ixs = utils.non_max_suppression(np.array(boxes), np.arange(N), 0.3)\n shapes = [s for i, s in enumerate(shapes) if i in keep_ixs]\n return bg_color, shapes",
"_____no_output_____"
],
[
"# Training dataset\ndataset_train = ShapesDataset()\ndataset_train.load_shapes(500, config.IMAGE_SHAPE[0], config.IMAGE_SHAPE[1])\ndataset_train.prepare()\n\n# Validation dataset\ndataset_val = ShapesDataset()\ndataset_val.load_shapes(50, config.IMAGE_SHAPE[0], config.IMAGE_SHAPE[1])\ndataset_val.prepare()",
"_____no_output_____"
],
[
"# Load and display random samples\nimage_ids = np.random.choice(dataset_train.image_ids, 4)\nfor image_id in image_ids:\n image = dataset_train.load_image(image_id)\n mask, class_ids = dataset_train.load_mask(image_id)\n visualize.display_top_masks(image, mask, class_ids, dataset_train.class_names)",
"_____no_output_____"
]
],
[
[
"## Create Model",
"_____no_output_____"
]
],
[
[
"# Create model in training mode\nmodel = modellib.MaskRCNN(mode=\"training\", config=config,\n model_dir=MODEL_DIR)",
"_____no_output_____"
],
[
"# Which weights to start with?\ninit_with = \"coco\" # imagenet, coco, or last\n\nif init_with == \"imagenet\":\n model.load_weights(model.get_imagenet_weights(), by_name=True)\nelif init_with == \"coco\":\n # Load weights trained on MS COCO, but skip layers that\n # are different due to the different number of classes\n # See README for instructions to download the COCO weights\n model.load_weights(COCO_MODEL_PATH, by_name=True,\n exclude=[\"mrcnn_class_logits\", \"mrcnn_bbox_fc\", \n \"mrcnn_bbox\", \"mrcnn_mask\"])\nelif init_with == \"last\":\n # Load the last model you trained and continue training\n model.load_weights(model.find_last(), by_name=True)",
"_____no_output_____"
]
],
[
[
"## Training\n\nTrain in two stages:\n1. Only the heads. Here we're freezing all the backbone layers and training only the randomly initialized layers (i.e. the ones that we didn't use pre-trained weights from MS COCO). To train only the head layers, pass `layers='heads'` to the `train()` function.\n\n2. Fine-tune all layers. For this simple example it's not necessary, but we're including it to show the process. Simply pass `layers=\"all` to train all layers.",
"_____no_output_____"
]
],
[
[
"# Train the head branches\n# Passing layers=\"heads\" freezes all layers except the head\n# layers. You can also pass a regular expression to select\n# which layers to train by name pattern.\nmodel.train(dataset_train, dataset_val, \n learning_rate=config.LEARNING_RATE, \n epochs=1, \n layers='heads')",
"Checkpoint Path: /deepmatter/mask_rcnn/logs/shapes2017102802/mask_rcnn_{epoch:04d}.h5\nStarting at epoch 0. LR=0.002\n\nSelecting layers to train\nfpn_c5p5 (Conv2D)\nfpn_c4p4 (Conv2D)\nfpn_c3p3 (Conv2D)\nfpn_c2p2 (Conv2D)\nfpn_p5 (Conv2D)\nfpn_p2 (Conv2D)\nfpn_p3 (Conv2D)\nfpn_p4 (Conv2D)\nIn model: rpn_model\n rpn_conv_shared (Conv2D)\n rpn_class_raw (Conv2D)\n rpn_bbox_pred (Conv2D)\nmrcnn_mask_conv1 (TimeDistributed)\nmrcnn_mask_bn1 (TimeDistributed)\nmrcnn_mask_conv2 (TimeDistributed)\nmrcnn_mask_bn2 (TimeDistributed)\nmrcnn_class_conv1 (TimeDistributed)\nmrcnn_class_bn1 (TimeDistributed)\nmrcnn_mask_conv3 (TimeDistributed)\nmrcnn_mask_bn3 (TimeDistributed)\nmrcnn_class_conv2 (TimeDistributed)\nmrcnn_class_bn2 (TimeDistributed)\nmrcnn_mask_conv4 (TimeDistributed)\nmrcnn_mask_bn4 (TimeDistributed)\nmrcnn_bbox_fc (TimeDistributed)\nmrcnn_mask_deconv (TimeDistributed)\nmrcnn_class_logits (TimeDistributed)\nmrcnn_mask (TimeDistributed)\n"
],
[
"# Fine tune all layers\n# Passing layers=\"all\" trains all layers. You can also \n# pass a regular expression to select which layers to\n# train by name pattern.\nmodel.train(dataset_train, dataset_val, \n learning_rate=config.LEARNING_RATE / 10,\n epochs=2, \n layers=\"all\")",
"Checkpoint Path: /deepmatter/mask_rcnn/logs/shapes2017102802/mask_rcnn_{epoch:04d}.h5\nStarting at epoch 0. LR=0.0002\n\nSelecting layers to train\nconv1 (Conv2D)\nbn_conv1 (BatchNorm)\nres2a_branch2a (Conv2D)\nbn2a_branch2a (BatchNorm)\nres2a_branch2b (Conv2D)\nbn2a_branch2b (BatchNorm)\nres2a_branch2c (Conv2D)\nres2a_branch1 (Conv2D)\nbn2a_branch2c (BatchNorm)\nbn2a_branch1 (BatchNorm)\nres2b_branch2a (Conv2D)\nbn2b_branch2a (BatchNorm)\nres2b_branch2b (Conv2D)\nbn2b_branch2b (BatchNorm)\nres2b_branch2c (Conv2D)\nbn2b_branch2c (BatchNorm)\nres2c_branch2a (Conv2D)\nbn2c_branch2a (BatchNorm)\nres2c_branch2b (Conv2D)\nbn2c_branch2b (BatchNorm)\nres2c_branch2c (Conv2D)\nbn2c_branch2c (BatchNorm)\nres3a_branch2a (Conv2D)\nbn3a_branch2a (BatchNorm)\nres3a_branch2b (Conv2D)\nbn3a_branch2b (BatchNorm)\nres3a_branch2c (Conv2D)\nres3a_branch1 (Conv2D)\nbn3a_branch2c (BatchNorm)\nbn3a_branch1 (BatchNorm)\nres3b_branch2a (Conv2D)\nbn3b_branch2a (BatchNorm)\nres3b_branch2b (Conv2D)\nbn3b_branch2b (BatchNorm)\nres3b_branch2c (Conv2D)\nbn3b_branch2c (BatchNorm)\nres3c_branch2a (Conv2D)\nbn3c_branch2a (BatchNorm)\nres3c_branch2b (Conv2D)\nbn3c_branch2b (BatchNorm)\nres3c_branch2c (Conv2D)\nbn3c_branch2c (BatchNorm)\nres3d_branch2a (Conv2D)\nbn3d_branch2a (BatchNorm)\nres3d_branch2b (Conv2D)\nbn3d_branch2b (BatchNorm)\nres3d_branch2c (Conv2D)\nbn3d_branch2c (BatchNorm)\nres4a_branch2a (Conv2D)\nbn4a_branch2a (BatchNorm)\nres4a_branch2b (Conv2D)\nbn4a_branch2b (BatchNorm)\nres4a_branch2c (Conv2D)\nres4a_branch1 (Conv2D)\nbn4a_branch2c (BatchNorm)\nbn4a_branch1 (BatchNorm)\nres4b_branch2a (Conv2D)\nbn4b_branch2a (BatchNorm)\nres4b_branch2b (Conv2D)\nbn4b_branch2b (BatchNorm)\nres4b_branch2c (Conv2D)\nbn4b_branch2c (BatchNorm)\nres4c_branch2a (Conv2D)\nbn4c_branch2a (BatchNorm)\nres4c_branch2b (Conv2D)\nbn4c_branch2b (BatchNorm)\nres4c_branch2c (Conv2D)\nbn4c_branch2c (BatchNorm)\nres4d_branch2a (Conv2D)\nbn4d_branch2a (BatchNorm)\nres4d_branch2b (Conv2D)\nbn4d_branch2b (BatchNorm)\nres4d_branch2c (Conv2D)\nbn4d_branch2c (BatchNorm)\nres4e_branch2a (Conv2D)\nbn4e_branch2a (BatchNorm)\nres4e_branch2b (Conv2D)\nbn4e_branch2b (BatchNorm)\nres4e_branch2c (Conv2D)\nbn4e_branch2c (BatchNorm)\nres4f_branch2a (Conv2D)\nbn4f_branch2a (BatchNorm)\nres4f_branch2b (Conv2D)\nbn4f_branch2b (BatchNorm)\nres4f_branch2c (Conv2D)\nbn4f_branch2c (BatchNorm)\nres4g_branch2a (Conv2D)\nbn4g_branch2a (BatchNorm)\nres4g_branch2b (Conv2D)\nbn4g_branch2b (BatchNorm)\nres4g_branch2c (Conv2D)\nbn4g_branch2c (BatchNorm)\nres4h_branch2a (Conv2D)\nbn4h_branch2a (BatchNorm)\nres4h_branch2b (Conv2D)\nbn4h_branch2b (BatchNorm)\nres4h_branch2c (Conv2D)\nbn4h_branch2c (BatchNorm)\nres4i_branch2a (Conv2D)\nbn4i_branch2a (BatchNorm)\nres4i_branch2b (Conv2D)\nbn4i_branch2b (BatchNorm)\nres4i_branch2c (Conv2D)\nbn4i_branch2c (BatchNorm)\nres4j_branch2a (Conv2D)\nbn4j_branch2a (BatchNorm)\nres4j_branch2b (Conv2D)\nbn4j_branch2b (BatchNorm)\nres4j_branch2c (Conv2D)\nbn4j_branch2c (BatchNorm)\nres4k_branch2a (Conv2D)\nbn4k_branch2a (BatchNorm)\nres4k_branch2b (Conv2D)\nbn4k_branch2b (BatchNorm)\nres4k_branch2c (Conv2D)\nbn4k_branch2c (BatchNorm)\nres4l_branch2a (Conv2D)\nbn4l_branch2a (BatchNorm)\nres4l_branch2b (Conv2D)\nbn4l_branch2b (BatchNorm)\nres4l_branch2c (Conv2D)\nbn4l_branch2c (BatchNorm)\nres4m_branch2a (Conv2D)\nbn4m_branch2a (BatchNorm)\nres4m_branch2b (Conv2D)\nbn4m_branch2b (BatchNorm)\nres4m_branch2c (Conv2D)\nbn4m_branch2c (BatchNorm)\nres4n_branch2a (Conv2D)\nbn4n_branch2a (BatchNorm)\nres4n_branch2b (Conv2D)\nbn4n_branch2b (BatchNorm)\nres4n_branch2c (Conv2D)\nbn4n_branch2c (BatchNorm)\nres4o_branch2a (Conv2D)\nbn4o_branch2a (BatchNorm)\nres4o_branch2b (Conv2D)\nbn4o_branch2b (BatchNorm)\nres4o_branch2c (Conv2D)\nbn4o_branch2c (BatchNorm)\nres4p_branch2a (Conv2D)\nbn4p_branch2a (BatchNorm)\nres4p_branch2b (Conv2D)\nbn4p_branch2b (BatchNorm)\nres4p_branch2c (Conv2D)\nbn4p_branch2c (BatchNorm)\nres4q_branch2a (Conv2D)\nbn4q_branch2a (BatchNorm)\nres4q_branch2b (Conv2D)\nbn4q_branch2b (BatchNorm)\nres4q_branch2c (Conv2D)\nbn4q_branch2c (BatchNorm)\nres4r_branch2a (Conv2D)\nbn4r_branch2a (BatchNorm)\nres4r_branch2b (Conv2D)\nbn4r_branch2b (BatchNorm)\nres4r_branch2c (Conv2D)\nbn4r_branch2c (BatchNorm)\nres4s_branch2a (Conv2D)\nbn4s_branch2a (BatchNorm)\nres4s_branch2b (Conv2D)\nbn4s_branch2b (BatchNorm)\nres4s_branch2c (Conv2D)\nbn4s_branch2c (BatchNorm)\nres4t_branch2a (Conv2D)\nbn4t_branch2a (BatchNorm)\nres4t_branch2b (Conv2D)\nbn4t_branch2b (BatchNorm)\nres4t_branch2c (Conv2D)\nbn4t_branch2c (BatchNorm)\nres4u_branch2a (Conv2D)\nbn4u_branch2a (BatchNorm)\nres4u_branch2b (Conv2D)\nbn4u_branch2b (BatchNorm)\nres4u_branch2c (Conv2D)\nbn4u_branch2c (BatchNorm)\nres4v_branch2a (Conv2D)\nbn4v_branch2a (BatchNorm)\nres4v_branch2b (Conv2D)\nbn4v_branch2b (BatchNorm)\nres4v_branch2c (Conv2D)\nbn4v_branch2c (BatchNorm)\nres4w_branch2a (Conv2D)\nbn4w_branch2a (BatchNorm)\nres4w_branch2b (Conv2D)\nbn4w_branch2b (BatchNorm)\nres4w_branch2c (Conv2D)\nbn4w_branch2c (BatchNorm)\nres5a_branch2a (Conv2D)\nbn5a_branch2a (BatchNorm)\nres5a_branch2b (Conv2D)\nbn5a_branch2b (BatchNorm)\nres5a_branch2c (Conv2D)\nres5a_branch1 (Conv2D)\nbn5a_branch2c (BatchNorm)\nbn5a_branch1 (BatchNorm)\nres5b_branch2a (Conv2D)\nbn5b_branch2a (BatchNorm)\nres5b_branch2b (Conv2D)\nbn5b_branch2b (BatchNorm)\nres5b_branch2c (Conv2D)\nbn5b_branch2c (BatchNorm)\nres5c_branch2a (Conv2D)\nbn5c_branch2a (BatchNorm)\nres5c_branch2b (Conv2D)\nbn5c_branch2b (BatchNorm)\nres5c_branch2c (Conv2D)\nbn5c_branch2c (BatchNorm)\nfpn_c5p5 (Conv2D)\nfpn_c4p4 (Conv2D)\nfpn_c3p3 (Conv2D)\nfpn_c2p2 (Conv2D)\nfpn_p5 (Conv2D)\nfpn_p2 (Conv2D)\nfpn_p3 (Conv2D)\nfpn_p4 (Conv2D)\nIn model: rpn_model\n rpn_conv_shared (Conv2D)\n rpn_class_raw (Conv2D)\n rpn_bbox_pred (Conv2D)\nmrcnn_mask_conv1 (TimeDistributed)\nmrcnn_mask_bn1 (TimeDistributed)\nmrcnn_mask_conv2 (TimeDistributed)\nmrcnn_mask_bn2 (TimeDistributed)\nmrcnn_class_conv1 (TimeDistributed)\nmrcnn_class_bn1 (TimeDistributed)\nmrcnn_mask_conv3 (TimeDistributed)\nmrcnn_mask_bn3 (TimeDistributed)\nmrcnn_class_conv2 (TimeDistributed)\nmrcnn_class_bn2 (TimeDistributed)\nmrcnn_mask_conv4 (TimeDistributed)\nmrcnn_mask_bn4 (TimeDistributed)\nmrcnn_bbox_fc (TimeDistributed)\nmrcnn_mask_deconv (TimeDistributed)\nmrcnn_class_logits (TimeDistributed)\nmrcnn_mask (TimeDistributed)\n"
],
[
"# Save weights\n# Typically not needed because callbacks save after every epoch\n# Uncomment to save manually\n# model_path = os.path.join(MODEL_DIR, \"mask_rcnn_shapes.h5\")\n# model.keras_model.save_weights(model_path)",
"_____no_output_____"
]
],
[
[
"## Detection",
"_____no_output_____"
]
],
[
[
"class InferenceConfig(ShapesConfig):\n GPU_COUNT = 1\n IMAGES_PER_GPU = 1\n\ninference_config = InferenceConfig()\n\n# Recreate the model in inference mode\nmodel = modellib.MaskRCNN(mode=\"inference\", \n config=inference_config,\n model_dir=MODEL_DIR)\n\n# Get path to saved weights\n# Either set a specific path or find last trained weights\n# model_path = os.path.join(ROOT_DIR, \".h5 file name here\")\nmodel_path = model.find_last()\n\n# Load trained weights\nprint(\"Loading weights from \", model_path)\nmodel.load_weights(model_path, by_name=True)",
"_____no_output_____"
],
[
"# Test on a random image\nimage_id = random.choice(dataset_val.image_ids)\noriginal_image, image_meta, gt_class_id, gt_bbox, gt_mask =\\\n modellib.load_image_gt(dataset_val, inference_config, \n image_id, use_mini_mask=False)\n\nlog(\"original_image\", original_image)\nlog(\"image_meta\", image_meta)\nlog(\"gt_class_id\", gt_class_id)\nlog(\"gt_bbox\", gt_bbox)\nlog(\"gt_mask\", gt_mask)\n\nvisualize.display_instances(original_image, gt_bbox, gt_mask, gt_class_id, \n dataset_train.class_names, figsize=(8, 8))",
"original_image shape: (128, 128, 3) min: 108.00000 max: 236.00000\nimage_meta shape: (12,) min: 0.00000 max: 128.00000\ngt_bbox shape: (2, 5) min: 2.00000 max: 102.00000\ngt_mask shape: (128, 128, 2) min: 0.00000 max: 1.00000\n"
],
[
"results = model.detect([original_image], verbose=1)\n\nr = results[0]\nvisualize.display_instances(original_image, r['rois'], r['masks'], r['class_ids'], \n dataset_val.class_names, r['scores'], ax=get_ax())",
"Processing 1 images\nimage shape: (128, 128, 3) min: 108.00000 max: 236.00000\nmolded_images shape: (1, 128, 128, 3) min: -15.70000 max: 132.10000\nimage_metas shape: (1, 12) min: 0.00000 max: 128.00000\n"
]
],
[
[
"## Evaluation",
"_____no_output_____"
]
],
[
[
"# Compute VOC-Style mAP @ IoU=0.5\n# Running on 10 images. Increase for better accuracy.\nimage_ids = np.random.choice(dataset_val.image_ids, 10)\nAPs = []\nfor image_id in image_ids:\n # Load image and ground truth data\n image, image_meta, gt_class_id, gt_bbox, gt_mask =\\\n modellib.load_image_gt(dataset_val, inference_config,\n image_id, use_mini_mask=False)\n molded_images = np.expand_dims(modellib.mold_image(image, inference_config), 0)\n # Run object detection\n results = model.detect([image], verbose=0)\n r = results[0]\n # Compute AP\n AP, precisions, recalls, overlaps =\\\n utils.compute_ap(gt_bbox, gt_class_id, gt_mask,\n r[\"rois\"], r[\"class_ids\"], r[\"scores\"], r['masks'])\n APs.append(AP)\n \nprint(\"mAP: \", np.mean(APs))",
"mAP: 0.95\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",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
]
] |
ece7bed7f9e8252c0d50d73214c55b56f531eeff | 62,866 | ipynb | Jupyter Notebook | exp/exp046_roberta_large_1dcnn.ipynb | TakoiHirokazu/Feedback-Prize-Evaluating-Student-Writing | 8aea7e67717b146f27766bba1b532b5cd1c0774e | [
"MIT"
] | null | null | null | exp/exp046_roberta_large_1dcnn.ipynb | TakoiHirokazu/Feedback-Prize-Evaluating-Student-Writing | 8aea7e67717b146f27766bba1b532b5cd1c0774e | [
"MIT"
] | null | null | null | exp/exp046_roberta_large_1dcnn.ipynb | TakoiHirokazu/Feedback-Prize-Evaluating-Student-Writing | 8aea7e67717b146f27766bba1b532b5cd1c0774e | [
"MIT"
] | null | null | null | 32.606846 | 255 | 0.492222 | [
[
[
"# ========================================\n# library\n# ========================================\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom sklearn.model_selection import StratifiedKFold, KFold,GroupKFold\nfrom sklearn.metrics import mean_squared_error\n%matplotlib inline\nimport torch\nimport torch.nn as nn\nfrom torch.utils.data import Dataset, DataLoader, Subset\nimport transformers\nfrom transformers import LongformerTokenizer, LongformerModel,AutoTokenizer,RobertaModel\nfrom transformers import AdamW, get_linear_schedule_with_warmup\nfrom torch.cuda.amp import autocast, GradScaler\nimport logging\nfrom ast import literal_eval\nimport sys\nfrom contextlib import contextmanager\nimport time\nimport random\nfrom tqdm import tqdm\nimport os",
"2022-02-14 01:21:48.579260: I tensorflow/stream_executor/platform/default/dso_loader.cc:49] Successfully opened dynamic library libcudart.so.11.0\n"
],
[
"# ==================\n# Constant\n# ==================\nex = \"046\"\nTRAIN_PATH = \"../data/train.csv\"\nDATA_DIR = \"../data/roberta-large/\"\nif not os.path.exists(f\"../output/exp/ex{ex}\"):\n os.makedirs(f\"../output/exp/ex{ex}\")\n os.makedirs(f\"../output/exp/ex{ex}/ex{ex}_model\")\n \nOUTPUT_DIR = f\"../output/exp/ex{ex}\"\nMODEL_PATH_BASE = f\"../output/exp/ex{ex}/ex{ex}_model/ex{ex}\"\nLOGGER_PATH = f\"../output/exp/ex{ex}/ex{ex}.txt\"\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")",
"_____no_output_____"
],
[
"# ===============\n# Configs\n# ===============\nSEED = 0\nN_SPLITS = 5\nSHUFFLE = True\nnum_workers = 4\nBATCH_SIZE = 8\n\nn_epochs = 6\nmax_len = 512\nweight_decay = 0.1\nbeta = (0.9, 0.98)\nlr = 2e-5\nnum_warmup_steps_rate = 0.1\n\nMODEL_PATH = 'roberta-large'\ntokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)",
"_____no_output_____"
],
[
"# ===============\n# Functions\n# ===============\ndef set_seed(seed: int = 42):\n random.seed(seed)\n np.random.seed(seed)\n os.environ[\"PYTHONHASHSEED\"] = str(seed)\n torch.manual_seed(seed)\n torch.cuda.manual_seed(seed)\n torch.backends.cudnn.deterministic = True\n torch.backends.cudnn.benchmark = False\n\ndef setup_logger(out_file=None, stderr=True, stderr_level=logging.INFO, file_level=logging.DEBUG):\n LOGGER.handlers = []\n LOGGER.setLevel(min(stderr_level, file_level))\n\n if stderr:\n handler = logging.StreamHandler(sys.stderr)\n handler.setFormatter(FORMATTER)\n handler.setLevel(stderr_level)\n LOGGER.addHandler(handler)\n\n if out_file is not None:\n handler = logging.FileHandler(out_file)\n handler.setFormatter(FORMATTER)\n handler.setLevel(file_level)\n LOGGER.addHandler(handler)\n\n LOGGER.info(\"logger set up\")\n return LOGGER\n\n\n@contextmanager\ndef timer(name):\n t0 = time.time()\n yield \n LOGGER.info(f'[{name}] done in {time.time() - t0:.0f} s')\n \n \nLOGGER = logging.getLogger()\nFORMATTER = logging.Formatter(\"%(asctime)s - %(levelname)s - %(message)s\")\nsetup_logger(out_file=LOGGER_PATH)",
"2022-02-14 01:21:53,687 - INFO - logger set up\n"
],
[
"class TrainDataset(Dataset):\n def __init__(self, token,attentiona_mask,label=None):\n self.len = len(token)\n self.token = token\n self.attention_mask = attentiona_mask\n self.label = label\n #self.get_wids = get_wids # for validation\n\n def __getitem__(self, index):\n # GET TEXT AND WORD LABELS \n if self.label is not None:\n return {\n 'token': torch.tensor(self.token[index], dtype=torch.long),\n 'mask': torch.tensor(self.attention_mask[index], dtype=torch.long),\n \"y\":torch.tensor(self.label[index], dtype=torch.float32)\n }\n else:\n return {\n 'token': torch.tensor(self.token[index], dtype=torch.long),\n 'mask': torch.tensor(self.attention_mask[index], dtype=torch.long),\n }\n\n def __len__(self):\n return self.len\n\nclass custom_model(nn.Module):\n def __init__(self):\n super(custom_model, self).__init__()\n self.backbone = RobertaModel.from_pretrained(\n MODEL_PATH, \n )\n \n #self.dropout = nn.Dropout(p=0.2)\n self.ln = nn.LayerNorm(1024)\n \n self.conv1= nn.Conv1d(1024, 512, kernel_size=3, padding=1)\n self.conv2= nn.Conv1d(1024, 512, kernel_size=9, padding=4)\n self.conv3= nn.Conv1d(1024, 512, kernel_size=15, padding=7)\n self.conv4= nn.Conv1d(1024, 512, kernel_size=31, padding=15)\n self.ln1 = nn.Sequential(nn.LayerNorm(512),\n nn.ReLU(),\n nn.Dropout(0.2))\n self.ln2 = nn.Sequential( nn.LayerNorm(512),\n nn.ReLU(),\n nn.Dropout(0.2))\n self.ln3 = nn.Sequential( nn.LayerNorm(512),\n nn.ReLU(),\n nn.Dropout(0.2))\n self.ln4 = nn.Sequential( nn.LayerNorm(512),\n nn.ReLU(),\n nn.Dropout(0.2))\n \n self.linear1 = nn.Sequential(\n nn.Linear(2048,1024),\n nn.LayerNorm(1024),\n nn.ReLU(),\n nn.Dropout(0.2),\n nn.Linear(1024,2),\n )\n self.linear2 = nn.Sequential(\n nn.Linear(2048,1024),\n nn.LayerNorm(1024),\n nn.ReLU(),\n nn.Dropout(0.2),\n nn.Linear(1024,2),\n )\n self.linear3 = nn.Sequential(\n nn.Linear(2048,1024),\n nn.LayerNorm(1024),\n nn.ReLU(),\n nn.Dropout(0.2),\n nn.Linear(1024,2),\n )\n self.linear4 = nn.Sequential(\n nn.Linear(2048,1024),\n nn.LayerNorm(1024),\n nn.ReLU(),\n nn.Dropout(0.2),\n nn.Linear(1024,2),\n )\n self.linear5 = nn.Sequential(\n nn.Linear(2048,1024),\n nn.LayerNorm(1024),\n nn.ReLU(),\n nn.Dropout(0.2),\n nn.Linear(1024,2),\n )\n self.linear6 = nn.Sequential(\n nn.Linear(2048,1024),\n nn.LayerNorm(1024),\n nn.ReLU(),\n nn.Dropout(0.2),\n nn.Linear(1024,2),\n )\n self.linear7 = nn.Sequential(\n nn.Linear(2048,1024),\n nn.LayerNorm(1024),\n nn.ReLU(),\n nn.Dropout(0.2),\n nn.Linear(1024,2),\n )\n self.linear8 = nn.Sequential(\n nn.Linear(2048,1024),\n nn.LayerNorm(1024),\n nn.ReLU(),\n nn.Dropout(0.2),\n nn.Linear(1024,1),\n )\n def forward(self, ids, mask):\n # pooler\n emb = self.backbone(ids, attention_mask=mask)[\"last_hidden_state\"]\n output = self.ln(emb)\n output = output.permute((0, 2, 1)).contiguous()\n output1 = self.conv1(output)\n output1 = self.ln1(output1.permute((0, 2, 1)).contiguous())\n output2 = self.conv2(output)\n output2 = self.ln2(output2.permute((0, 2, 1)).contiguous())\n output3 = self.conv3(output)\n output3 = self.ln3(output3.permute((0, 2, 1)).contiguous())\n output4 = self.conv4(output)\n output4 = self.ln4(output4.permute((0, 2, 1)).contiguous())\n output_concat = torch.cat([output1,output2,output3,output4],axis=-1)\n output2_1 = self.linear1(output_concat)\n output2_2 = self.linear2(output_concat)\n output2_3 = self.linear3(output_concat)\n output2_4 = self.linear4(output_concat)\n output2_5 = self.linear5(output_concat)\n output2_6 = self.linear6(output_concat)\n output2_7= self.linear7(output_concat)\n output2_8 = self.linear8(output_concat)\n out = torch.cat(\n [output2_1,output2_2,output2_3,output2_4,\n output2_5,output2_6,output2_7,output2_8], axis=2)\n return out",
"_____no_output_____"
],
[
"target_map_rev = {0:'Lead', 1:'Position', 2:'Evidence', 3:'Claim', 4:'Concluding Statement',\n 5:'Counterclaim', 6:'Rebuttal', 7:'blank'}\n\ndef get_preds_collate(dataset, verbose,text_ids, preds, preds_len):\n all_predictions = []\n\n for id_num in tqdm(range(len(preds))):\n \n # GET ID\n #if (id_num%100==0)&(verbose): \n # print(id_num,', ',end='')\n n = text_ids[id_num]\n max_len = int(preds_len[id_num])\n # GET TOKEN POSITIONS IN CHARS\n name = f'../data/{dataset}/{n}.txt'\n txt = open(name, 'r').read()\n tokens = tokenizer.encode_plus(txt, max_length=max_len, padding='max_length',\n truncation=True, return_offsets_mapping=True)\n off = tokens['offset_mapping']\n \n # GET WORD POSITIONS IN CHARS\n w = []\n blank = True\n for i in range(len(txt)):\n if (txt[i]!=' ')&(txt[i]!='\\n')&(txt[i]!='\\xa0')&(txt[i]!='\\x85')&(blank==True):\n w.append(i)\n blank=False\n elif (txt[i]==' ')|(txt[i]=='\\n')|(txt[i]=='\\xa0')|(txt[i]=='\\x85'):\n blank=True\n w.append(1e6)\n \n # MAPPING FROM TOKENS TO WORDS\n word_map = -1 * np.ones(max_len,dtype='int32')\n w_i = 0\n for i in range(len(off)):\n if off[i][1]==0: continue\n while off[i][0]>=w[w_i+1]: w_i += 1\n word_map[i] = int(w_i)\n \n # CONVERT TOKEN PREDICTIONS INTO WORD LABELS\n ### KEY: ###\n # 0: LEAD_B, 1: LEAD_I\n # 2: POSITION_B, 3: POSITION_I\n # 4: EVIDENCE_B, 5: EVIDENCE_I\n # 6: CLAIM_B, 7: CLAIM_I\n # 8: CONCLUSION_B, 9: CONCLUSION_I\n # 10: COUNTERCLAIM_B, 11: COUNTERCLAIM_I\n # 12: REBUTTAL_B, 13: REBUTTAL_I\n # 14: NOTHING i.e. O\n ### NOTE THESE VALUES ARE DIVIDED BY 2 IN NEXT CODE LINE\n pred = preds[id_num,]/2.0\n \n i = 0\n while i<max_len:\n prediction = []\n start = pred[i]\n if start in [0,1,2,3,4,5,6,7]:\n prediction.append(word_map[i])\n i += 1\n if i>=max_len: break\n while pred[i]==start+0.5:\n if not word_map[i] in prediction:\n prediction.append(word_map[i])\n i += 1\n if i>=max_len: break\n else:\n i += 1\n prediction = [x for x in prediction if x!=-1]\n if len(prediction)>4:\n all_predictions.append( (n, target_map_rev[int(start)], \n ' '.join([str(x) for x in prediction]) ) )\n \n # MAKE DATAFRAME\n df = pd.DataFrame(all_predictions)\n df.columns = ['id','class','predictionstring']\n \n return df\n\n\ndef calc_overlap(row):\n \"\"\"\n Calculates the overlap between prediction and\n ground truth and overlap percentages used for determining\n true positives.\n \"\"\"\n set_pred = set(row.predictionstring_pred.split(' '))\n set_gt = set(row.predictionstring_gt.split(' '))\n # Length of each and intersection\n len_gt = len(set_gt)\n len_pred = len(set_pred)\n inter = len(set_gt.intersection(set_pred))\n overlap_1 = inter / len_gt\n overlap_2 = inter/ len_pred\n return [overlap_1, overlap_2]\n\n\ndef score_feedback_comp(pred_df, gt_df):\n \"\"\"\n A function that scores for the kaggle\n Student Writing Competition\n \n Uses the steps in the evaluation page here:\n https://www.kaggle.com/c/feedback-prize-2021/overview/evaluation\n \"\"\"\n gt_df = gt_df[['id','discourse_type','predictionstring']] \\\n .reset_index(drop=True).copy()\n pred_df = pred_df[['id','class','predictionstring']] \\\n .reset_index(drop=True).copy()\n pred_df['pred_id'] = pred_df.index\n gt_df['gt_id'] = gt_df.index\n # Step 1. all ground truths and predictions for a given class are compared.\n joined = pred_df.merge(gt_df,\n left_on=['id','class'],\n right_on=['id','discourse_type'],\n how='outer',\n suffixes=('_pred','_gt')\n )\n joined['predictionstring_gt'] = joined['predictionstring_gt'].fillna(' ')\n joined['predictionstring_pred'] = joined['predictionstring_pred'].fillna(' ')\n\n joined['overlaps'] = joined.apply(calc_overlap, axis=1)\n\n # 2. If the overlap between the ground truth and prediction is >= 0.5, \n # and the overlap between the prediction and the ground truth >= 0.5,\n # the prediction is a match and considered a true positive.\n # If multiple matches exist, the match with the highest pair of overlaps is taken.\n joined['overlap1'] = joined['overlaps'].apply(lambda x: eval(str(x))[0])\n joined['overlap2'] = joined['overlaps'].apply(lambda x: eval(str(x))[1])\n\n\n joined['potential_TP'] = (joined['overlap1'] >= 0.5) & (joined['overlap2'] >= 0.5)\n joined['max_overlap'] = joined[['overlap1','overlap2']].max(axis=1)\n tp_pred_ids = joined.query('potential_TP') \\\n .sort_values('max_overlap', ascending=False) \\\n .groupby(['id','predictionstring_gt']).first()['pred_id'].values\n\n # 3. Any unmatched ground truths are false negatives\n # and any unmatched predictions are false positives.\n fp_pred_ids = [p for p in joined['pred_id'].unique() if p not in tp_pred_ids]\n\n matched_gt_ids = joined.query('potential_TP')['gt_id'].unique()\n unmatched_gt_ids = [c for c in joined['gt_id'].unique() if c not in matched_gt_ids]\n\n # Get numbers of each type\n TP = len(tp_pred_ids)\n FP = len(fp_pred_ids)\n FN = len(unmatched_gt_ids)\n #calc microf1\n my_f1_score = TP / (TP + 0.5*(FP+FN))\n return my_f1_score\n\ndef collate(d,train=True):\n mask_len = int(d[\"mask\"].sum(axis=1).max())\n if train:\n return {\"token\" : d['token'][:,:mask_len],\n \"mask\" : d['mask'][:,:mask_len],\n \"y\" : d['y'][:,:mask_len],\n \"max_len\" : mask_len}\n else:\n return {\"token\" : d['token'][:,:mask_len],\n \"mask\" : d['mask'][:,:mask_len],\n \"max_len\" : mask_len}",
"_____no_output_____"
],
[
"# ================================\n# Main\n# ================================\ntrain = pd.read_csv(TRAIN_PATH)\nIDS = train.id.unique()\nid_array = np.array(IDS)",
"_____no_output_____"
],
[
"# ================================\n# data load\n# ================================\ntargets = np.load(DATA_DIR + f\"targets_{max_len}.npy\")\ntrain_tokens = np.load(DATA_DIR + f\"tokens_{max_len}.npy\")\ntrain_attention = np.load(DATA_DIR + f\"attention_{max_len}.npy\")",
"_____no_output_____"
],
[
"# ================================\n# train\n# ================================\nwith timer(\"roberta_large\"):\n set_seed(SEED)\n oof = pd.DataFrame()\n oof_pred = np.ndarray((0,max_len,15))\n kf = KFold(n_splits=N_SPLITS, shuffle=SHUFFLE, random_state=SEED)\n for fold, (train_idx, valid_idx) in enumerate(kf.split(id_array)):\n print(f\"fold{fold}:start\")\n x_train_token, x_train_attention, y_train = train_tokens[train_idx], train_attention[train_idx], targets[train_idx]\n x_val_token, x_val_attention, y_val = train_tokens[valid_idx], train_attention[valid_idx], targets[valid_idx]\n train_val = train[train.id.isin(id_array[valid_idx])].reset_index(drop=True)\n \n # dataset\n train_ = TrainDataset( x_train_token, x_train_attention, y_train)\n val_ = TrainDataset( x_val_token, x_val_attention, y_val)\n \n # loader\n train_loader = DataLoader(dataset=train_, batch_size=BATCH_SIZE, shuffle = True ,pin_memory=True)\n val_loader = DataLoader(dataset=val_, batch_size=BATCH_SIZE, shuffle = False , pin_memory=True)\n \n # model\n model = custom_model()\n model = model.to(device)\n \n # optimizer, scheduler\n param_optimizer = list(model.named_parameters())\n no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight']\n optimizer_grouped_parameters = [\n {'params': [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)], 'weight_decay': weight_decay},\n {'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}\n ]\n optimizer = AdamW(optimizer_grouped_parameters,\n lr=lr,\n betas=beta,\n weight_decay=weight_decay,\n )\n num_train_optimization_steps = int(len(train_loader) * n_epochs)\n num_warmup_steps = int(num_train_optimization_steps * num_warmup_steps_rate)\n scheduler = get_linear_schedule_with_warmup(optimizer,\n num_warmup_steps=num_warmup_steps,\n num_training_steps=num_train_optimization_steps)\n \n criterion = nn.BCEWithLogitsLoss()\n best_val = 0\n \n for epoch in range(n_epochs):\n print(f\"============start epoch:{epoch}==============\")\n model.train() \n val_losses_batch = []\n scaler = GradScaler()\n for i, d in tqdm(enumerate(train_loader),total=len(train_loader)):\n d = collate(d)\n ids = d['token'].to(device)\n mask = d['mask'].to(device)\n labels = d['y'].to(device)\n #labels = labels.unsqueeze(-1)\n optimizer.zero_grad()\n with autocast():\n output = model(ids,mask)\n loss = criterion(output[mask == 1], labels[mask == 1])\n scaler.scale(loss).backward()\n #torch.nn.utils.clip_grad_norm_(model.parameters(), clip_grad_norm)\n scaler.step(optimizer)\n scaler.update()\n scheduler.step()\n \n y_pred2 = []\n val_preds = np.ndarray((0,max_len,15))\n val_len = np.ndarray(0)\n model.eval() # switch model to the evaluation mode\n with torch.no_grad(): \n # Predicting on validation set\n \n for d in tqdm(val_loader,total=len(val_loader)):\n # =========================\n # data loader\n # =========================\n d = collate(d)\n ids = d['token'].to(device)\n mask = d['mask'].to(device)\n with autocast():\n outputs = model(ids, mask)\n outputs = np.concatenate([outputs.sigmoid().detach().cpu().numpy(),np.zeros([len(outputs),max_len - d[\"max_len\"],15])],axis=1)\n val_preds = np.concatenate([val_preds, outputs], axis=0)\n val_len = np.concatenate([val_len,np.array([d[\"max_len\"] for i in range(len(ids))])],axis=0)\n val_preds_max = np.argmax(val_preds,axis=-1)\n oof_ = get_preds_collate( dataset='train', verbose=True, text_ids=id_array[valid_idx],\n preds = val_preds_max,preds_len=val_len) \n # COMPUTE F1 SCORE\n f1s = []\n CLASSES = oof_['class'].unique()\n print()\n for c in CLASSES:\n pred_df = oof_.loc[oof_['class']==c].copy()\n gt_df = train_val.loc[train_val['discourse_type']==c].copy()\n f1 = score_feedback_comp(pred_df, gt_df)\n print(c,f1)\n f1s.append(f1)\n score = np.mean(f1s)\n LOGGER.info(f'{fold},{epoch}:{i},val_score:{score}')\n if best_val < score:\n print(\"save model weight\")\n best_val = score\n best_val_preds = val_preds\n oof_best = oof_.copy()\n torch.save(model.state_dict(), MODEL_PATH_BASE + f\"_{fold}.pth\") # Saving current best model\n oof_best[\"fold\"] = fold\n oof_best.to_csv(OUTPUT_DIR + f\"/ex{ex}_oof_{fold}.csv\",index=False)\n np.save(OUTPUT_DIR + f\"/ex{ex}_oof_npy_{fold}.npy\",best_val_preds)",
"fold0:start\n"
],
[
"oof = pd.DataFrame()\nfor i in range(5):\n oof__ = pd.read_csv(OUTPUT_DIR + f\"/ex{ex}_oof_{i}.csv\")\n oof = pd.concat([oof,oof__]).reset_index(drop=True)\n# COMPUTE F1 SCORE\nf1s = []\nCLASSES = oof['class'].unique()\nfor c in CLASSES:\n pred_df = oof.loc[oof['class']==c].copy()\n gt_df = train.loc[train['discourse_type']==c].copy()\n f1 = score_feedback_comp(pred_df, gt_df)\n print(c,f1)\n f1s.append(f1)\nscore = np.mean(f1s)\nLOGGER.info(f'CV:{score}')",
"Lead 0.823718808693319\nClaim 0.6090094006411998\nPosition 0.7003339742940998\nEvidence 0.6761049075724875\nConcluding Statement 0.6019067703527965\nCounterclaim 0.47756956274843837\n"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ece7c29aaad0f468e345ecef28e823833e864576 | 12,362 | ipynb | Jupyter Notebook | AI 이노베이션 스퀘어 음성지능 과정/20200927/lab-11_6_PackedSequence.ipynb | donddog/AI_Innovation_Square_Codes | a04d50db011d25e00d8486146c24124c50242aa7 | [
"MIT"
] | 1 | 2021-02-11T16:45:21.000Z | 2021-02-11T16:45:21.000Z | AI 이노베이션 스퀘어 음성지능 과정/20200927/lab-11_6_PackedSequence.ipynb | donddog/AI_Innovation_Square_Codes | a04d50db011d25e00d8486146c24124c50242aa7 | [
"MIT"
] | null | null | null | AI 이노베이션 스퀘어 음성지능 과정/20200927/lab-11_6_PackedSequence.ipynb | donddog/AI_Innovation_Square_Codes | a04d50db011d25e00d8486146c24124c50242aa7 | [
"MIT"
] | null | null | null | 25.228571 | 168 | 0.517877 | [
[
[
"### PackedSequence 와 PaddedSequence\n\n[링크: PackedSequence에 대한 PyTorch 공식 문서](https://pytorch.org/docs/stable/nn.html#packedsequence)\n\n이 튜토리얼에서는 RNN / LSTM 계열의 모델에서 sequence batch를 잘 활용할 수 있는 `PackedSequence` 와 `PaddedSequence`를 만드는 법을 배워보겠습니다.\n\nPyTorch 라이브러리 안에는 다음 4가지 함수들이 주어집니다.\n\n`pad_sequence`, `pack_sequence`, `pack_padded_sequence`, `pad_packed_sequence`",
"_____no_output_____"
]
],
[
[
"import torch\nimport numpy as np\nfrom torch.nn.utils.rnn import pad_sequence, pack_sequence, pack_padded_sequence, pad_packed_sequence",
"_____no_output_____"
]
],
[
[
"### 예제 데이터",
"_____no_output_____"
]
],
[
[
"data = ['hello world',\n 'midnight',\n 'calculation',\n 'path',\n 'short circuit']\n\nchar_set = ['<pad>'] + list(set(char for seq in data for char in seq)) # Get all characters and include pad token\nchar2idx = {char: idx for idx, char in enumerate(char_set)} # Constuct character to index dictionary\n\nprint('char_set:', char_set)\nprint('char_set length:', len(char_set))",
"char_set: ['<pad>', 't', 'l', 'r', 'm', 'd', 'u', 'w', ' ', 'p', 'e', 'g', 's', 'o', 'i', 'a', 'h', 'n', 'c']\nchar_set length: 19\n"
],
[
"X = [torch.LongTensor([char2idx[char] for char in seq]) for seq in data]\n\nfor sequence in X:\n print(sequence)",
"tensor([16, 10, 2, 2, 13, 8, 7, 13, 3, 2, 5])\ntensor([ 4, 14, 5, 17, 14, 11, 16, 1])\ntensor([18, 15, 2, 18, 6, 2, 15, 1, 14, 13, 17])\ntensor([ 9, 15, 1, 16])\ntensor([12, 16, 13, 3, 1, 8, 18, 14, 3, 18, 6, 14, 1])\n"
],
[
"lengths = [len(seq) for seq in X]\nprint('lengths:', lengths)",
"lengths: [11, 8, 11, 4, 13]\n"
]
],
[
[
"### Sequence 데이터의 경우 어떻게 batch로 묶을까요?\n\n위와같이 Text 나 audio 처럼 sequence 형식인 데이터의 경우 길이가 각각 다 다르기 때문에 \n\n하나의 batch로 만들어주기 위해서 일반적으로 제일 긴 sequence 길이에 맞춰 뒷부분에 padding을 추가해줍니다.\n\n이 방식이 일반적으로 많이 쓰이는 Padding 방식입니다.\n\n하지만 PyTorch에서는 `PackedSequence`라는 것을 쓰면 padding 없이도 정확히 필요한 부분까지만 병렬 계산을 할 수 있습니다.",
"_____no_output_____"
],
[
"### `pad_sequence` 함수를 이용하여 PaddedSequence (그냥 Tensor) 만들기\n\n사실, PaddedSequence는 sequence중에서 가장 긴 sequence와 길이를 맞추어주기 위해 padding을 추가한 일반적인 **Tensor**를 말합니다.\n\n(따로 PaddedSequence라는 class는 존재하지 않습니다.)\n\n이때, `pad_sequence`라는 PyTorch 기본 라이브러리 함수를 이용하면 쉽게 padding을 추가할 수 있습니다.\n\n여기서 주의하실 점은 input이 **Tensor들의 list** 로 주어져야합니다. (그냥 **Tensor** 가 아닌 **Tensor들의 list** 입니다.)\n\nlist 안에 있는 각각의 Tensor들의 shape가 `(?, a, b, ...)` 라고 할때, (여기서 ?는 각각 다른 sequence length 입니다.)\n\n`pad_sequence` 함수를 쓰면 `(T, batch_size, a, b, ...)` shape를 가지는 Tensor가 리턴됩니다. \n(여기서 `T`는 batch안에서 가장 큰 sequence length 입니다.)\n\n만약, `pad_sequence`에 명시적으로 `batch_first=True`라는 파라미터를 지정해주면, \n\n`(batch_size, T, a, b, ...)` shape를 가지는 Tensor가 리턴됩니다. \n\n기본적으로 padding 값은 0으로 되어있지만, `padding_value=42`와 같이 파라미터를 지정해주면, padding하는 값도 정할 수 있습니다.",
"_____no_output_____"
]
],
[
[
"padded_sequence = pad_sequence(X, batch_first=True)\n\nprint(padded_sequence)\nprint(padded_sequence.shape)",
"tensor([[16, 10, 2, 2, 13, 8, 7, 13, 3, 2, 5, 0, 0],\n [ 4, 14, 5, 17, 14, 11, 16, 1, 0, 0, 0, 0, 0],\n [18, 15, 2, 18, 6, 2, 15, 1, 14, 13, 17, 0, 0],\n [ 9, 15, 1, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0],\n [12, 16, 13, 3, 1, 8, 18, 14, 3, 18, 6, 14, 1]])\ntorch.Size([5, 13])\n"
]
],
[
[
"### `pack_sequence` 함수를 이용하여 PackedSequence 만들기\n\nPackedSequence는 위와같이 padding token을 추가하여 sequence의 최대 길이에 맞는 Tensor를 만드는게 아닌,\n\npadding을 추가하지 않고 정확히 주어진 sequence 길이까지만 모델이 연산을 하게끔 만드는 PyTorch의 자료구조입니다.\n\n이 PackedSequence를 만들기 위해서는 한가지 조건이 필요합니다.\n- **주어지는 input (list of Tensor)는 길이에 따른 내림차순으로 정렬이 되어있어야 합니다.**\n\n따라서 먼저 input을 길이에 따른 내림차순으로 정렬해봅시다.",
"_____no_output_____"
]
],
[
[
"sorted_idx = sorted(range(len(lengths)), key=lengths.__getitem__, reverse=True)\nsorted_X = [X[idx] for idx in sorted_idx]\n\nfor sequence in sorted_X:\n print(sequence)",
"tensor([12, 16, 13, 3, 1, 8, 18, 14, 3, 18, 6, 14, 1])\ntensor([16, 10, 2, 2, 13, 8, 7, 13, 3, 2, 5])\ntensor([18, 15, 2, 18, 6, 2, 15, 1, 14, 13, 17])\ntensor([ 4, 14, 5, 17, 14, 11, 16, 1])\ntensor([ 9, 15, 1, 16])\n"
]
],
[
[
"`pack_sequence`를 이용하여 PackedSequence를 만들어보겠습니다.",
"_____no_output_____"
]
],
[
[
"packed_sequence = pack_sequence(sorted_X)\n\nprint(packed_sequence)",
"PackedSequence(data=tensor([12, 16, 18, 4, 9, 16, 10, 15, 14, 15, 13, 2, 2, 5, 1, 3, 2, 18,\n 17, 16, 1, 13, 6, 14, 8, 8, 2, 11, 18, 7, 15, 16, 14, 13, 1, 1,\n 3, 3, 14, 18, 2, 13, 6, 5, 17, 14, 1]), batch_sizes=tensor([5, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 1, 1]), sorted_indices=None, unsorted_indices=None)\n"
]
],
[
[
"### Embedding 적용해보기\n자 이제, `PackedSequence`와 padding이 된 Tensor인 `PaddedSequence`를 만들어보았으니, RNN에 input으로 넣어서 테스트해보려고 합니다.\n\n그 전에, 위에 예제들에서는 input이 character의 index들을 가지고 있는 데이터였지만, 보통은 주로 이를 embedding한 값을 RNN의 input으로 넣어줍니다.\n\n이 튜토리얼에서는 one-hot character embedding을 해보도록 하겠습니다.",
"_____no_output_____"
]
],
[
[
"eye = torch.eye(len(char_set))\nembedded_tensor = eye[padded_sequence]\nprint(embedded_tensor.shape)",
"torch.Size([5, 13, 19])\n"
],
[
"embedded_packed_seq = pack_sequence([eye[X[idx]] for idx in sorted_idx])\n\nprint(embedded_packed_seq.data.shape)",
"torch.Size([47, 19])\n"
]
],
[
[
"### RNN 모델 만들기",
"_____no_output_____"
]
],
[
[
"rnn = torch.nn.RNN(input_size=len(char_set), hidden_size=30, batch_first=True)",
"_____no_output_____"
]
],
[
[
"`PaddedSequence`를 이용하여 RNN에 넣어봅시다.",
"_____no_output_____"
]
],
[
[
"rnn_output, hidden = rnn(embedded_tensor)\n\nprint(rnn_output.shape)\nprint(hidden.shape)",
"torch.Size([5, 13, 30])\ntorch.Size([1, 5, 30])\n"
]
],
[
[
"`PackedSequence`를 이용하여 RNN에 넣어봅시다.",
"_____no_output_____"
]
],
[
[
"rnn_output, hidden = rnn(embedded_packed_seq)\n\nprint(rnn_output.data.shape)\nprint(hidden.data.shape)",
"torch.Size([47, 30])\ntorch.Size([1, 5, 30])\n"
]
],
[
[
"### `pad_packed_sequence`\n\n위 함수는 `PackedSequence`를 `PaddedSequence`(Tensor)로 바꾸어주는 함수입니다.\n\n`PackedSequence`는 각 sequence에 대한 길이 정보도 가지고있기 때문에, 이 함수는 Tensor와 함께 길이에 대한 리스트를 튜플로 리턴해줍니다.\n\n리턴값: (Tensor, list_of_lengths)",
"_____no_output_____"
]
],
[
[
"unpacked_sequence, seq_lengths = pad_packed_sequence(embedded_packed_seq, batch_first=True)\n\nprint(unpacked_sequence.shape)\nprint(seq_lengths)",
"torch.Size([5, 13, 19])\ntensor([13, 11, 11, 8, 4])\n"
]
],
[
[
"## # `pack_padded_sequence`\n반대로, Padding이 된 Tensor인 `PaddedSequence`를 `PackedSequence`로 바꾸어주는 함수도 있습니다.\n\n`pack_padded_sequence` 함수는 실제 sequence길이에 대한 정보를 모르기때문에, 파라미터로 꼭 제공해주어야합니다.\n\n여기서 주의하여야 할 점은, input인 `PaddedSequence`가 아까 언급드린 **길이에 따른 내림차순으로 정렬되어야 한다는** 조건이 성립되어야 `PackedSequence`로 올바르게 변환될 수 있습니다.\n\n아까 저희가 만든 `padded_sequence` 변수는 이 조건을 만족하지 않기 때문에 다시 새로 만들어보겠습니다.",
"_____no_output_____"
]
],
[
[
"embedded_padded_sequence = eye[pad_sequence(sorted_X, batch_first=True)]\n\nprint(embedded_padded_sequence.shape)",
"torch.Size([5, 13, 19])\n"
]
],
[
[
"이제 이 padding이 된 Tensor를 `PackedSequence`로 변환해보겠습니다.",
"_____no_output_____"
]
],
[
[
"sorted_lengths = sorted(lengths, reverse=True)\nnew_packed_sequence = pack_padded_sequence(embedded_padded_sequence, sorted_lengths, batch_first=True)\nprint(new_packed_sequence.data.shape)\nprint(new_packed_sequence.batch_sizes)",
"torch.Size([47, 19])\ntensor([5, 5, 5, 5, 4, 4, 4, 4, 3, 3, 3, 1, 1])\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",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
ece7c7f212eb77669a8de9dca706a78c89b50114 | 16,845 | ipynb | Jupyter Notebook | Google Analytics/Google_Analytics_Get_stats_per_country.ipynb | techthiyanes/awesome-notebooks | 10ab4da1b94dfa101e908356a649609b0b17561a | [
"BSD-3-Clause"
] | null | null | null | Google Analytics/Google_Analytics_Get_stats_per_country.ipynb | techthiyanes/awesome-notebooks | 10ab4da1b94dfa101e908356a649609b0b17561a | [
"BSD-3-Clause"
] | null | null | null | Google Analytics/Google_Analytics_Get_stats_per_country.ipynb | techthiyanes/awesome-notebooks | 10ab4da1b94dfa101e908356a649609b0b17561a | [
"BSD-3-Clause"
] | null | null | null | 29.500876 | 311 | 0.632473 | [
[
[
"<img width=\"10%\" alt=\"Naas\" src=\"https://landen.imgix.net/jtci2pxwjczr/assets/5ice39g4.png?w=160\"/>",
"_____no_output_____"
],
[
"# Google Analytics - Get stats per country\n<a href=\"https://app.naas.ai/user-redirect/naas/downloader?url=https://raw.githubusercontent.com/jupyter-naas/awesome-notebooks/master/Google%20Analytics/Google_Analytics_Get_stats_per_country.ipynb\" target=\"_parent\"><img src=\"https://naasai-public.s3.eu-west-3.amazonaws.com/open_in_naas.svg\"/></a>",
"_____no_output_____"
],
[
"**Tags:** #googleanalytics #statspercountry #marketing #analytics #automation #image #csv #html #plotly",
"_____no_output_____"
],
[
"**Author:** [Charles Demontigny](https://www.linkedin.com/in/charles-demontigny/)",
"_____no_output_____"
],
[
"Pre-requisite: Create your own <a href=\"\">Google API JSON credential</a>",
"_____no_output_____"
],
[
"## Input",
"_____no_output_____"
],
[
"### Import library",
"_____no_output_____"
]
],
[
[
"try:\n import pycountry\nexcept:\n !pip install pycountry\n import pycountry\nimport plotly.graph_objects as go\nimport plotly.express as px\nimport naas\nfrom naas_drivers import googleanalytics",
"_____no_output_____"
]
],
[
[
"### Get your credential from Google Cloud Platform",
"_____no_output_____"
]
],
[
[
"json_path = 'naas-googleanalytics.json'",
"_____no_output_____"
]
],
[
[
"### Get view id from google analytics",
"_____no_output_____"
]
],
[
[
"view_id = \"228952707\"",
"_____no_output_____"
]
],
[
[
"### Schedule your notebook",
"_____no_output_____"
]
],
[
[
"naas.scheduler.add(cron=\"0 8 * * *\")\nnaas.dependency.add(json_path)\n\n#-> Uncomment the line below (by removing the hashtag) to remove your scheduler\n# naas.scheduler.delete()",
"_____no_output_____"
]
],
[
[
"## Model",
"_____no_output_____"
],
[
"### Visitor's country of origin",
"_____no_output_____"
]
],
[
[
"df_country = googleanalytics.connect(json_path=json_path).views.get_data(\n view_id,\n metrics=\"ga:sessions\",\n pivots_dimensions=\"ga:country\",\n dimensions=\"ga:month\",\n start_date=None,\n end_date=None,\n format_type=\"pivot\"\n)\ndf_country",
"_____no_output_____"
],
[
"sessions_per_country = googleanalytics.connect(json_path=json_path).views.get_country(view_id) # default: metrics=\"ga:sessions\"",
"_____no_output_____"
],
[
"sessions_per_country",
"_____no_output_____"
],
[
"users_per_country = googleanalytics.views.get_country(view_id, metrics=\"ga:users\") ",
"_____no_output_____"
]
],
[
[
"## Output",
"_____no_output_____"
],
[
"### Display result",
"_____no_output_____"
]
],
[
[
"sessions_per_country.head()",
"_____no_output_____"
],
[
"users_per_country.head()",
"_____no_output_____"
],
[
"sessions_per_country = sessions_per_country.reset_index().rename(columns={\"index\": \"Country\"})\nmapping = {country.name: country.alpha_3 for country in pycountry.countries}\nsessions_per_country['iso_alpha'] = sessions_per_country['Country'].apply(lambda x: mapping.get(x))",
"_____no_output_____"
],
[
"sessions_per_country",
"_____no_output_____"
],
[
"fig = px.choropleth(sessions_per_country, locations=\"iso_alpha\",\n color=\"Sessions\", \n hover_name=\"Country\",\n color_continuous_scale=\"Greens\")\nfig.show()",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
]
] |
ece7cc92cea46552674eeee3ae5eab246198c496 | 6,199 | ipynb | Jupyter Notebook | Choropleth_map_of_India_for_Covid/realtime-visualization-of-covid-19-data-of-india.ipynb | anishsingh20/COVID-19-INDIA-TRACKER | 2185caf16c08a03d92936f4fca88a2e4b870e4ed | [
"Apache-2.0"
] | 6 | 2020-03-27T06:09:12.000Z | 2022-01-24T11:42:12.000Z | Choropleth_map_of_India_for_Covid/realtime-visualization-of-covid-19-data-of-india.ipynb | anishsingh20/COVID-19-INDIA-TRACKER | 2185caf16c08a03d92936f4fca88a2e4b870e4ed | [
"Apache-2.0"
] | null | null | null | Choropleth_map_of_India_for_Covid/realtime-visualization-of-covid-19-data-of-india.ipynb | anishsingh20/COVID-19-INDIA-TRACKER | 2185caf16c08a03d92936f4fca88a2e4b870e4ed | [
"Apache-2.0"
] | 5 | 2020-05-04T16:36:04.000Z | 2020-10-02T08:38:44.000Z | 6,199 | 6,199 | 0.724149 | [
[
[
"## The global spread of corona virus has motivated to data analysts to come up with ways to visualise country-wise data using various techniques. However, I went a step ahead and made an ****attempt to visualise my country's (India) COVID-19 data****. This notebook shows choropleth map visualisations of this data. Instead of using a static dataset, I've used data directly from a webservice, where the data is updated on a daily basis. Therefore, this notebook shows new visualisations everytime it's run.",
"_____no_output_____"
],
[
"## A List of libraries and modules used:\n1. Geopandas\n2. Pandas\n3. requests\n4. Matplotlib",
"_____no_output_____"
],
[
"# Choropleth map using [Geopandas](http://https://geopandas.org/#:~:text=GeoPandas%20is%20an%20open%20source,operations%20are%20performed%20by%20shapely.) library\nFor these maps, I have used two data sources. The first is a dataset of COVID-19 cases in every state of India. The aim is to produce a map on real time data. Therefore, instead of using a static datasource, like a .csv or an excel file, I have used the data derived from a web service. This code directly fetches data from the web using a request module. The data from this service is updated on a daily basis. So, whenever the code is run, the map is updated automatically. The data can be accessed from: \n\n[https://covid-india-cases.herokuapp.com/states/](http://)\n\nThe requests module fetces data from the source provided.",
"_____no_output_____"
]
],
[
[
"pip install geopandas",
"_____no_output_____"
],
[
"import geopandas as gpd\nimport pandas as pd\nimport requests\nimport matplotlib.pyplot as plt\n%matplotlib inline",
"_____no_output_____"
]
],
[
[
"## Fetching COVID 19 Data for Indian States ",
"_____no_output_____"
]
],
[
[
"raw= requests.get(\"https://covid-india-cases.herokuapp.com/states/\")\nraw_json = raw.json()\ndf = pd.DataFrame(raw_json)\ndf.head()",
"_____no_output_____"
]
],
[
[
"Keeping only the desired columns in dataframe",
"_____no_output_____"
]
],
[
[
"df=df[[\"state\",\"active\",\"deaths\",\"cured\"]]\ndf.head()",
"_____no_output_____"
]
],
[
[
"## Getting data for the map\nThe next dataset that is required is a shapefile of all the states. A shape file consists of the geometry of each state on a map. For this I have used the Geopandas library",
"_____no_output_____"
]
],
[
[
"fp = \"../input/india-shapefile/INDIA.shp\"\nmap_df = gpd.read_file(fp)\nmap_df.head()",
"_____no_output_____"
],
[
"map_df.plot()",
"_____no_output_____"
]
],
[
[
"## Replacing the names of some countries so that they match with the ones in the data provided by the webservice",
"_____no_output_____"
]
],
[
[
"map_df[\"ST_NAME\"].replace({\"DADRA AND NAGAR HAVELI\": \"Dadra and Nagar Haveli and Daman and Diu\", \"Andaman & Nicobar Island\": \"Andaman and Nicobar Islands\", \"Pondicherry\": \"Puducherry\",\"Orissa\":\"Odisha\",\"Nct Of Delhi\":\"Delhi\",\"LAKSHADWEEP\":\"Lakshadweep\",\"CHANDIGARH\":\"Chandigarh\",\"DAMAN AND DIU\":\"Dadra and Nagar Haveli and Daman and Diu\",\"ANDAMAN AND NICOBAR ISLANDS\":\"Andaman and Nicobar Islands\",\"Jammu And Kashmir\":\"Jammu and Kashmir\"}, inplace=True)",
"_____no_output_____"
]
],
[
[
"## Merging both the datasets to obtain a final dataset with the state's name, it’s geometry and the COVID-19 data",
"_____no_output_____"
]
],
[
[
"merged = map_df.set_index('ST_NAME').join(df.set_index('state'))\nmerged.head()",
"_____no_output_____"
]
],
[
[
"# Plotting the map\nSince it's a choropleth map, we first have to specify a variable which decides the colour of a particular state.\nFor the first map, I want the criteria to be the number of active cases. Therefore, the column with the name 'active' is passed to the plot function to make the corresponding map",
"_____no_output_____"
]
],
[
[
"variable = 'active'\n# create figure and axes for Matplotlib\nfig, ax = plt.subplots(1,figsize=(18, 13))\nax.axis('off')\nmerged.plot(column=variable, cmap='bone_r', linewidth=0.5, ax=ax, edgecolor='0.6', legend='True')",
"_____no_output_____"
]
],
[
[
"# Map of recovered cases",
"_____no_output_____"
]
],
[
[
"variable2 = 'cured'\n# create figure and axes for Matplotlib\nfig, ax = plt.subplots(1,figsize=(18, 13))\nax.axis('off')\nmerged.plot(column=variable2, cmap='Greens', linewidth=0.5, ax=ax, edgecolor='0.6', legend='True')",
"_____no_output_____"
]
],
[
[
"# Map of death cases",
"_____no_output_____"
]
],
[
[
"variable3 = 'deaths'\n# create figure and axes for Matplotlib\nfig, ax = plt.subplots(1,figsize=(18, 13))\nax.axis('off')\nmerged.plot(column=variable3, cmap='Reds', linewidth=0.5, ax=ax, edgecolor='0.6', legend='True')",
"_____no_output_____"
]
]
] | [
"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"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
ece7f5ea176c65daa1029e5cfe84246ecc3bf8e7 | 614,408 | ipynb | Jupyter Notebook | day1/5_modelmnist.ipynb | bkamins/ComplexNetworks2019 | d652364e1e66aa89e96d3a726652fbf3835c73f3 | [
"MIT"
] | 3 | 2019-08-20T13:07:16.000Z | 2021-03-12T01:34:47.000Z | day1/5_modelmnist.ipynb | bkamins/ComplexNetworks2019 | d652364e1e66aa89e96d3a726652fbf3835c73f3 | [
"MIT"
] | null | null | null | day1/5_modelmnist.ipynb | bkamins/ComplexNetworks2019 | d652364e1e66aa89e96d3a726652fbf3835c73f3 | [
"MIT"
] | 2 | 2019-08-12T23:29:15.000Z | 2020-01-30T22:46:41.000Z | 98.336748 | 40,403 | 0.724576 | [
[
[
"empty"
]
]
] | [
"empty"
] | [
[
"empty"
]
] |
ece7fb5ac8f6be4eeb479b17b8b1d5e5556bc968 | 5,350 | ipynb | Jupyter Notebook | examples/hello_world/hello_world.ipynb | antmicro/tensorflow-arduino-examples | 47662b61cea883766396c26c6e01a238c67af655 | [
"Apache-2.0"
] | 16 | 2020-12-22T17:55:06.000Z | 2022-03-22T19:22:19.000Z | examples/hello_world/hello_world.ipynb | antmicro/tensorflow-arduino-examples | 47662b61cea883766396c26c6e01a238c67af655 | [
"Apache-2.0"
] | 5 | 2020-12-28T08:31:41.000Z | 2021-01-22T12:39:13.000Z | examples/hello_world/hello_world.ipynb | antmicro/tensorflow-arduino-examples | 47662b61cea883766396c26c6e01a238c67af655 | [
"Apache-2.0"
] | 6 | 2020-12-22T17:54:32.000Z | 2022-03-22T19:22:22.000Z | 30.924855 | 323 | 0.616822 | [
[
[
"\n<table align=\"left\">\n <td>\n <a target=\"_blank\" href=\"https://colab.research.google.com/github/antmicro/tensorflow-arduino-examples/blob/master/examples/hello_world/hello_world.ipynb\"><img src=\"https://raw.githubusercontent.com/antmicro/tensorflow-arduino-examples/master/examples/.static/view-in-colab.png\" />Run in Google Colab</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://github.com/antmicro/tensorflow-arduino-examples/blob/master/examples/hello_world/hello_world.ipynb\"><img src=\"https://raw.githubusercontent.com/antmicro/tensorflow-arduino-examples/master/examples/.static/view-ipynb.png\" />View ipynb on GitHub</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://github.com/antmicro/tensorflow-arduino-examples/blob/master/examples/hello_world/hello_world.py\"><img src=\"https://raw.githubusercontent.com/antmicro/tensorflow-arduino-examples/master/examples/.static/view-source.png\" />View Python source on GitHub</a>\n </td>\n</table>",
"_____no_output_____"
],
[
"## Install requirements",
"_____no_output_____"
]
],
[
[
"!pip install -q git+https://github.com/antmicro/pyrenode.git git+https://github.com/antmicro/renode-colab-tools.git\n!mkdir -p renode && cd renode && wget https://dl.antmicro.com/projects/renode/builds/renode-latest.linux-portable.tar.gz && tar -xzf renode-latest.linux-portable.tar.gz --strip 1\n!pip install -q -r renode/tests/requirements.txt\n\nimport os\nfrom renode_colab_tools import metrics\nos.environ['PATH'] = os.getcwd()+\"/renode:\"+os.environ['PATH']\nos.environ['TENSORFLOW_PATH'] = os.getcwd()+\"/tensorflow-arduino-examples/tensorflow\"",
"_____no_output_____"
],
[
"!mkdir -p binaries/hello_world && cd binaries/hello_world && wget https://github.com/antmicro/tensorflow-arduino-examples-binaries/raw/master/hello_world/hello_world.ino.elf # fetch prebuilt binaries",
"_____no_output_____"
]
],
[
[
"## Run the hello_world example in Renode",
"_____no_output_____"
]
],
[
[
"import time\nfrom pyrenode import *\nshutdown_renode()\nconnect_renode() # this sets up a log file, and clears the simulation (just in case)\ntell_renode('using sysbus')\ntell_renode('mach create')\ntell_renode('machine LoadPlatformDescription @platforms/boards/arduino_nano_33_ble.repl')\ntell_renode('sysbus LoadELF @binaries/hello_world/hello_world.ino.elf')\n\ntell_renode('uart0 CreateFileBackend @uart.dump true')\ntell_renode('logLevel 3')\ntell_renode('machine EnableProfiler @metrics.dump')\ntell_renode('s')\nwhile not os.path.exists('renode/uart.dump'):\n time.sleep(1) #waits for creating uart.dump\n!timeout 60 tail -c+2 -f renode/uart.dump | sed '/^1$/ q'\ntell_renode('q')\nexpect_cli('Renode is quitting')\ntime.sleep(1) #wait not to kill Renode forcefully\nshutdown_renode()",
"_____no_output_____"
]
],
[
[
"## Renode metrics analysis",
"_____no_output_____"
]
],
[
[
"from renode.tools.metrics_analyzer.metrics_parser import MetricsParser\nmetrics.init_notebook_mode(connected=False)\nparser = MetricsParser('renode/metrics.dump')",
"_____no_output_____"
],
[
"metrics.configure_plotly_browser_state()\nmetrics.show_executed_instructions(parser)",
"_____no_output_____"
],
[
"metrics.configure_plotly_browser_state()\nmetrics.show_memory_access(parser)",
"_____no_output_____"
],
[
"metrics.configure_plotly_browser_state()\nmetrics.show_exceptions(parser)",
"_____no_output_____"
],
[
"metrics.configure_plotly_browser_state()\nmetrics.show_peripheral_access(parser)",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
]
] |
ece801e14b6d1617e9519e9c83f65300fea76f41 | 159,026 | ipynb | Jupyter Notebook | 1st component/Step 1 - Process EDA, accelerometer and skin temperature data.ipynb | ddritsa/PhD-Thesis-repository | 512850326fcdd56e29ea519a054a9668d92c2046 | [
"MIT"
] | null | null | null | 1st component/Step 1 - Process EDA, accelerometer and skin temperature data.ipynb | ddritsa/PhD-Thesis-repository | 512850326fcdd56e29ea519a054a9668d92c2046 | [
"MIT"
] | null | null | null | 1st component/Step 1 - Process EDA, accelerometer and skin temperature data.ipynb | ddritsa/PhD-Thesis-repository | 512850326fcdd56e29ea519a054a9668d92c2046 | [
"MIT"
] | null | null | null | 402.597468 | 37,528 | 0.93298 | [
[
[
"import sys\n# Put here the directory containing the folder where the definitions are saved\nsys.path.insert(0, r'C:\\Users\\demdr\\UTS\\Important files for PhD thesis\\Definitions')\n",
"_____no_output_____"
],
[
"import matplotlib.pyplot as plt\nimport pandas as pd \nimport numpy as np\n\nfrom definitions_for_opening_E4_files_and_making_a_df import create_final_dict\nfrom definitions_for_EDA_feature_extraction_and_activity_recognition import resample_EDA_df, create_EDA_features, detect_activity\nfrom definitions_for_activity_recognition import detect_change_of_intensity",
"Using TensorFlow backend.\nc:\\users\\demdr\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:526: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n _np_qint8 = np.dtype([(\"qint8\", np.int8, 1)])\nc:\\users\\demdr\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:527: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n _np_quint8 = np.dtype([(\"quint8\", np.uint8, 1)])\nc:\\users\\demdr\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:528: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n _np_qint16 = np.dtype([(\"qint16\", np.int16, 1)])\nc:\\users\\demdr\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:529: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n _np_quint16 = np.dtype([(\"quint16\", np.uint16, 1)])\nc:\\users\\demdr\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:530: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n _np_qint32 = np.dtype([(\"qint32\", np.int32, 1)])\nc:\\users\\demdr\\python37\\lib\\site-packages\\tensorflow\\python\\framework\\dtypes.py:535: FutureWarning: Passing (type, 1) or '1type' as a synonym of type is deprecated; in a future version of numpy, it will be understood as (type, (1,)) / '(1,)type'.\n np_resource = np.dtype([(\"resource\", np.ubyte, 1)])\n"
],
[
"# Put here the directory of the folder where the EDA data is saved \n# This should be the folder with the EDA data, which is downloaded from the Empatica E4 manager\n# For downloading the Empatica E4 data from the E4 manager, see here the directions: https://support.empatica.com/hc/en-us/articles/206389995-Download-your-data-from-the-E4-wristband\n# This code uses the files 'EDA.csv', 'ACC.csv', 'HR.csv' and 'TEMP.csv' from this folder\n\n# Ideally we should have a separate folder for each user, to store their data\n# Otherwise we have to tweak a bit the initial code in the 'definitions_for_opening_E4_files_and_making_a_df' file\n\n# ATTENTION: The path that we specify should correspond to a folder that has another folder (or more), containing the following csv files \n# of the session that we want to analyse: \n# 'EDA.csv', 'ACC.csv', 'HR.csv' and 'TEMP.csv' \n# DO NOT put directly the path of the final folder that contains the csv files \n# Instead, put the path of its parent folder\n# For instance, imagine the following directories: \n# ...\\Project data\\Raw data\\Participants: The name of the folder containing all the raw data from all participants\n# ...\\Project data\\Raw data\\Participants\\A : The path of the folder containing the data of participant A within that folder\n# ...\\Project data\\Raw data\\Participants\\A\\EDA data : The folder where we have all the unzipped EDA data for this participant, from many recording sessions\n# ...\\Project data\\Raw data\\Participants\\A\\EDA data\\Session 1 : This is the parent folder that we want. 'Session 1' is just a name for this session. Inside, it has another folder with unzipped EDA data for one session. \n# ...\\Project data\\Raw data\\Participants\\A\\EDA data\\Session 1\\1460023847_A00A98 : The name of the unzipped folder with the EDA data for this session\n# Inside this folder, there are csv files for EDA, ACC, HR, TEMP, like this:\n# ...\\Project data\\Raw data\\Participants\\A\\EDA data\\Session 1\\1460023847_A00A98\\EDA.csv ...and so on\n# From all these directories, we put the directory '...\\Project data\\Raw data\\Participants\\A\\EDA data\\Session 1' \n# to analyse the data of session 1 for user A\n\n#this_directory = 'XXXXXXXXX' # replace this with the appropriate directory name\n#For the example described above, we would put the following directory: \nthis_directory = r'C:\\Users\\demdr\\Desktop\\Testing the thesis functions\\Project data\\Raw data\\Participants\\A\\EDA data\\Session 1'\n#participant_ID = 'YYYYYYYY' # Put here the participant ID; this could be a randomly assigned string or integer or anything else \n# For the example described above, we would do the following:\nparticipant_ID = 'A'\n\nall_data_together = create_final_dict(this_directory)",
"2019-07-16 13:09:55+10:00\n0.04247095584869385\n"
]
],
[
[
"### EDA and activity feature extraction",
"_____no_output_____"
]
],
[
[
"for_final_EDA_df = pd.DataFrame()\n\nfor ses in all_data_together['E4_Session'].unique():\n this_df = all_data_together[all_data_together['E4_Session']==ses]\n\n # The following are the definitions for feature extraction:\n this_df_resampled = resample_EDA_df(this_df)\n this_df_resampled = create_EDA_features(this_df_resampled)\n #activity recognition\n this_df_resampled = detect_activity(this_df_resampled)\n this_df_resampled\n # Plot some of the extracted data if we want\n plt.figure(figsize=(20,3))\n plt.plot(this_df_resampled['EDA'])\n plt.plot(this_df_resampled['EDA_tonic'])\n plt.title('Extracted tonic EDA')\n plt.figure(figsize=(20,3))\n plt.plot(this_df_resampled['EDA artifact'])\n plt.title('EDA artefacts')\n plt.figure(figsize=(20,3))\n plt.plot(this_df_resampled['EDR_amplitude'])\n plt.title('EDA amplitude')\n plt.figure(figsize=(20,3))\n plt.plot(this_df_resampled['activity'])\n plt.title('Classified activity from accelerometer data')\n\n \n new_df = this_df_resampled.copy()\n new_df['Detected Activity']=new_df['activity'].copy()\n new_df = detect_change_of_intensity(new_df)\n\n\n this_df_resampled['Change of activity state'] = new_df['Change of activity state_After prediction']\n this_df_resampled['Steady state'] = new_df['Steady state']\n this_df_resampled['Change of movement intensity'] = new_df['Change of movement intensity_After prediction']\n this_df_resampled['Spontaneous movement'] = new_df['Spontaneous movement_After prediction']\n \n for_final_EDA_df = for_final_EDA_df.append(this_df_resampled)\n ",
"art\npercentage of artifacts: 22 9995 0.0022011005502751376\n[ 0 80 120 280 320 520 560 1040 1080 1200 1240 1760 2920 3440\n 3560 3960 4000 4520 4560 5080 5440 6160 6200 6240 7400 7560 8200 8240\n 8280 8320 8360 8480 8560 8720 8760 8920 9040 9080 9160 9400 9440 9480\n 9520 9560 9720 9760 9800 9880 9961]\n"
]
],
[
[
"#### visualise the extracted changes in activity",
"_____no_output_____"
]
],
[
[
"\nfor ses in for_final_EDA_df['E4_Session'].unique():\n this_df = for_final_EDA_df[for_final_EDA_df['E4_Session']==ses]\n plt.figure(figsize=(20,3))\n plt.plot(this_df['Change of activity state'])\n plt.title('Change of activity state')\n plt.figure(figsize=(20,3))\n plt.plot(this_df['Change of movement intensity'])\n plt.title('Change of movement intensity')\n\n",
"_____no_output_____"
]
],
[
[
"#### Construct a df with only selected columns",
"_____no_output_____"
]
],
[
[
"for_final_EDA_df['HR_from e4']=for_final_EDA_df['HR'].copy()\nfor_final_EDA_df['Participant_ID']=participant_ID\n\n\nfinal_EDA_df = pd.concat([for_final_EDA_df['EDA'],\nfor_final_EDA_df['ACC_1'],\nfor_final_EDA_df['ACC_2'],\nfor_final_EDA_df['ACC_3'],\nfor_final_EDA_df['HR_from e4'],\nfor_final_EDA_df['EDA_session'],\nfor_final_EDA_df['EDA artifact'],\nfor_final_EDA_df['EDA artifact'],\nfor_final_EDA_df['Stress'],\nfor_final_EDA_df['TEMP_smoothed'],\nfor_final_EDA_df['EDA_tonic'],\nfor_final_EDA_df['EDR_amplitude'],\nfor_final_EDA_df['EDA_duration'],\nfor_final_EDA_df['EDA_duration'],\nfor_final_EDA_df['percentage_of_EDA_artifacts'],\nfor_final_EDA_df['activity'],\nfor_final_EDA_df['activity_2s'],\nfor_final_EDA_df['Change of activity state'],\nfor_final_EDA_df['Steady state'],\nfor_final_EDA_df['Change of movement intensity'],\nfor_final_EDA_df['Spontaneous movement']],axis=1)\n\n\n\n\n\nfinal_EDA_df = final_EDA_df.fillna(method='bfill')\nfinal_EDA_df = final_EDA_df.fillna(method='ffill')\n",
"_____no_output_____"
]
],
[
[
"### Save here the extracted data",
"_____no_output_____"
]
],
[
[
"# Put here the directory for saving the constructed file \n#path_to_save = r'ZZZZZZZZ.csv' \n# This file contains the processed EDA and activity data,with timestamps\n\n# For the example described above, we would use the following file for saving the csv: \npath_to_save = r'C:\\Users\\demdr\\Desktop\\Testing the thesis functions\\Project data\\Analysed data\\Participants\\ID\\E4 data\\Session 1.csv'\npath_to_save = path_to_save.replace('ID',participant_ID)\nprint(path_to_save)\n\n\n\nfinal_EDA_df.to_csv(path_to_save)",
"C:\\Users\\demdr\\Desktop\\Testing the thesis functions\\Project data\\Analysed data\\Participants\\A\\E4 data\\Session 1.csv\n"
]
]
] | [
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
ece80540a8863916d4a3b359206d9c185469e702 | 385,513 | ipynb | Jupyter Notebook | example/Demo.ipynb | k-utsubo/bert_score | 1e5d0abc298829d693d574032b781c63409a71b3 | [
"MIT"
] | null | null | null | example/Demo.ipynb | k-utsubo/bert_score | 1e5d0abc298829d693d574032b781c63409a71b3 | [
"MIT"
] | null | null | null | example/Demo.ipynb | k-utsubo/bert_score | 1e5d0abc298829d693d574032b781c63409a71b3 | [
"MIT"
] | null | null | null | 561.154294 | 129,218 | 0.944848 | [
[
[
"## BERTScore Tutorial",
"_____no_output_____"
],
[
"### Installation\nif you have not installed `bert_score`, it is very easy\nsimply uncomment the line below to install through pip",
"_____no_output_____"
]
],
[
[
"!pip install bert_score",
"Collecting bert_score\n Using cached bert_score-0.3.10-py3-none-any.whl (59 kB)\nRequirement already satisfied: pandas>=1.0.1 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from bert_score) (1.3.4)\nRequirement already satisfied: matplotlib in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from bert_score) (3.4.3)\nRequirement already satisfied: torch>=1.0.0 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from bert_score) (1.10.0)\nRequirement already satisfied: packaging>=20.9 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from bert_score) (21.2)\nRequirement already satisfied: requests in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from bert_score) (2.26.0)\nRequirement already satisfied: transformers>=3.0.0numpy in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from bert_score) (4.12.3)\nRequirement already satisfied: tqdm>=4.31.1 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from bert_score) (4.62.3)\nRequirement already satisfied: pyparsing<3,>=2.0.2 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from packaging>=20.9->bert_score) (2.4.7)\nRequirement already satisfied: python-dateutil>=2.7.3 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from pandas>=1.0.1->bert_score) (2.8.2)\nRequirement already satisfied: pytz>=2017.3 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from pandas>=1.0.1->bert_score) (2021.3)\nRequirement already satisfied: numpy>=1.20.0 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from pandas>=1.0.1->bert_score) (1.21.4)\nRequirement already satisfied: six>=1.5 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from python-dateutil>=2.7.3->pandas>=1.0.1->bert_score) (1.16.0)\nRequirement already satisfied: typing-extensions in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from torch>=1.0.0->bert_score) (3.10.0.2)\nRequirement already satisfied: regex!=2019.12.17 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from transformers>=3.0.0numpy->bert_score) (2021.11.2)\nRequirement already satisfied: pyyaml>=5.1 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from transformers>=3.0.0numpy->bert_score) (6.0)\nRequirement already satisfied: filelock in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from transformers>=3.0.0numpy->bert_score) (3.3.2)\nRequirement already satisfied: sacremoses in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from transformers>=3.0.0numpy->bert_score) (0.0.46)\nRequirement already satisfied: huggingface-hub<1.0,>=0.1.0 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from transformers>=3.0.0numpy->bert_score) (0.1.2)\nRequirement already satisfied: tokenizers<0.11,>=0.10.1 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from transformers>=3.0.0numpy->bert_score) (0.10.3)\nRequirement already satisfied: cycler>=0.10 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from matplotlib->bert_score) (0.11.0)\nRequirement already satisfied: kiwisolver>=1.0.1 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from matplotlib->bert_score) (1.3.2)\nRequirement already satisfied: pillow>=6.2.0 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from matplotlib->bert_score) (8.4.0)\nRequirement already satisfied: urllib3<1.27,>=1.21.1 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from requests->bert_score) (1.26.7)\nRequirement already satisfied: idna<4,>=2.5 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from requests->bert_score) (3.3)\nRequirement already satisfied: certifi>=2017.4.17 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from requests->bert_score) (2021.10.8)\nRequirement already satisfied: charset-normalizer~=2.0.0 in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from requests->bert_score) (2.0.7)\nRequirement already satisfied: joblib in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from sacremoses->transformers>=3.0.0numpy->bert_score) (1.1.0)\nRequirement already satisfied: click in /Volumes/DATA/src/bert_score/venv/lib/python3.9/site-packages (from sacremoses->transformers>=3.0.0numpy->bert_score) (8.0.3)\nInstalling collected packages: bert-score\nSuccessfully installed bert-score-0.3.10\n\u001b[33mWARNING: You are using pip version 21.2.3; however, version 21.3.1 is available.\nYou should consider upgrading via the '/Volumes/DATA/src/bert_score/venv/bin/python -m pip install --upgrade pip' command.\u001b[0m\n"
],
[
"# check your installation\nimport bert_score\nbert_score.__version__",
"_____no_output_____"
]
],
[
[
"### preparation",
"_____no_output_____"
]
],
[
[
"# hide the loading messages\nimport logging\nimport transformers\ntransformers.tokenization_utils.logger.setLevel(logging.ERROR)\ntransformers.configuration_utils.logger.setLevel(logging.ERROR)\ntransformers.modeling_utils.logger.setLevel(logging.ERROR)",
"_____no_output_____"
],
[
"%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom matplotlib import rcParams\n\nrcParams[\"xtick.major.size\"] = 0\nrcParams[\"xtick.minor.size\"] = 0\nrcParams[\"ytick.major.size\"] = 0\nrcParams[\"ytick.minor.size\"] = 0\n\nrcParams[\"axes.labelsize\"] = \"large\"\nrcParams[\"axes.axisbelow\"] = True\nrcParams[\"axes.grid\"] = True",
"_____no_output_____"
]
],
[
[
"## Function API",
"_____no_output_____"
],
[
"We will first demonstrate how to use the `score` function in `bert_score`, which is what you need to evaluate a set of machine generated outputs.",
"_____no_output_____"
]
],
[
[
"from bert_score import score",
"_____no_output_____"
]
],
[
[
"Inputs to `score` are a list of candidate sentences and a list of reference sentences. ",
"_____no_output_____"
]
],
[
[
"with open(\"hyps.txt\") as f:\n cands = [line.strip() for line in f]\n\nwith open(\"refs.txt\") as f:\n refs = [line.strip() for line in f]",
"_____no_output_____"
],
[
"cands",
"_____no_output_____"
]
],
[
[
"Let's have a look.",
"_____no_output_____"
]
],
[
[
"cands[0]",
"_____no_output_____"
]
],
[
[
"We are now ready to call the score function. Besides candidates and references, we need to speicify the bert model we are using. Since we are dealing with English sentences, we will use the *bert-base-uncased* model.",
"_____no_output_____"
]
],
[
[
"P, R, F1 = score(cands, refs, lang='en', verbose=True)",
"Downloading: 100%|██████████| 482/482 [00:00<00:00, 202kB/s]\nDownloading: 100%|██████████| 878k/878k [00:00<00:00, 904kB/s] \nDownloading: 100%|██████████| 446k/446k [00:00<00:00, 684kB/s]\nDownloading: 100%|██████████| 1.29M/1.29M [00:01<00:00, 1.30MB/s]\nDownloading: 100%|██████████| 1.33G/1.33G [00:17<00:00, 81.4MB/s]\n"
]
],
[
[
"The outputs of the `score` function are Tensors of precision, recall, and F1 respectively. Each Tensor has the same number of items with the candidate and reference lists. Each item in the list is a scalar, representing the score for the corresponding candidates and references.",
"_____no_output_____"
]
],
[
[
"F1",
"_____no_output_____"
]
],
[
[
"We can take the average of all candidate reference pairs to be the system level score.",
"_____no_output_____"
]
],
[
[
"print(f\"System level F1 score: {F1.mean():.3f}\")",
"System level F1 score: 0.959\n"
]
],
[
[
"It might also be very interestig to see the distribution of BERTScore.",
"_____no_output_____"
]
],
[
[
"import matplotlib.pyplot as plt",
"_____no_output_____"
],
[
"plt.hist(F1, bins=20)\nplt.xlabel(\"score\")\nplt.ylabel(\"counts\")\nplt.show()",
"_____no_output_____"
]
],
[
[
"Some contextual embedding models, like RoBERTa, often produce BERTScores in a very narrow range (as shown above, the range is roughly between 0.92 and 1). Although this artifact does not affect the ranking ability of BERTScore, it affects the readability. Therefore, we propose to apply \"baseline rescaling\" to adjust the output scores. More details on this feature can be found in [this post](https://github.com/Tiiiger/bert_score/blob/master/journal/rescale_baseline.md).",
"_____no_output_____"
]
],
[
[
"P, R, F1 = score(cands, refs, lang='en', rescale_with_baseline=True)",
"_____no_output_____"
]
],
[
[
"We can now see that the scores are much more spread out, which makes it easy to compare different examples.",
"_____no_output_____"
]
],
[
[
"plt.hist(F1, bins=20)\nplt.xlabel(\"score\")\nplt.ylabel(\"counts\")\nplt.show()",
"_____no_output_____"
]
],
[
[
"The `score` function also handles multiple references gracefully. Consider a candidate sentences with 3 references.",
"_____no_output_____"
]
],
[
[
"single_cands = ['I like lemons.']\nmulti_refs = [['I am proud of you.', 'I love lemons.', 'Go go go.']]",
"_____no_output_____"
],
[
"P_mul, R_mul, F_mul = score(single_cands, multi_refs, lang=\"en\", rescale_with_baseline=True)",
"_____no_output_____"
]
],
[
[
"The `score` function will return the best score among all the references automatically.",
"_____no_output_____"
]
],
[
[
"F_mul",
"_____no_output_____"
]
],
[
[
"To understand a text generation system better, we can visualize the matchings in BERTScore.",
"_____no_output_____"
]
],
[
[
"from bert_score import plot_example",
"_____no_output_____"
],
[
"plot_example(cands[0], refs[0], lang=\"en\")",
"_____no_output_____"
]
],
[
[
"Similarly, we can apply rescaling to adjust the similarity distribution to be more distinguishable.",
"_____no_output_____"
]
],
[
[
"plot_example(cands[0], refs[0], lang=\"en\", rescale_with_baseline=True)",
"_____no_output_____"
]
],
[
[
"## Object-oriented API",
"_____no_output_____"
],
[
"In practice, most of the time of calling the `score` function is spent on building the model. In situations when we want to call the `score` function repeatedly, it is better to cache the model in a `scorer` object. Hence, in `bert_score` we also provide an object-oriented API. \n\nThe `BERTScorer` class provides the two methods we have introduced above, `score` and `plot_example`.",
"_____no_output_____"
]
],
[
[
"from bert_score import BERTScorer",
"_____no_output_____"
],
[
"scorer = BERTScorer(lang=\"en\", rescale_with_baseline=True)",
"_____no_output_____"
],
[
"P, R, F1 = scorer.score(cands, refs)",
"_____no_output_____"
],
[
"F1",
"_____no_output_____"
],
[
"scorer.plot_example(cands[0], refs[0])",
"_____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",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
]
] |
ece808d16745e560bb426e323ce843130bd938a8 | 150,819 | ipynb | Jupyter Notebook | examples/SWAN_example.ipynb | ryancoe/MHKiT-Python | e2564d6f22a4a19aadd29568838366e58741f88c | [
"BSD-3-Clause"
] | null | null | null | examples/SWAN_example.ipynb | ryancoe/MHKiT-Python | e2564d6f22a4a19aadd29568838366e58741f88c | [
"BSD-3-Clause"
] | 3 | 2020-06-23T17:16:38.000Z | 2021-01-20T23:43:28.000Z | examples/SWAN_example.ipynb | ryancoe/MHKiT-Python | e2564d6f22a4a19aadd29568838366e58741f88c | [
"BSD-3-Clause"
] | null | null | null | 104.445291 | 27,192 | 0.773351 | [
[
[
"# MHKiT SWAN Example\n\nThis example notebook demonstrates the input and plotting of output data from the software [Simulating WAves Nearshore (SWAN)](http://swanmodel.sourceforge.net/) using MHKiT. In this example the [SNL-SWAN](https://github.com/SNL-WaterPower/SNL-SWAN) tutorial was run for a wave energy converter. The output was written in ASCII and binary (*.mat) files. This MHKiT example notebook demonstrates how to import these different files into MHKiT and plot the output data. First, we will import the MHKiT SWAN package and the other Python packages needed for this example. Secondly, we will create an operating system independent path to the folder housing the SWAN data used in this example `swan_data_folder` using the `join` funtion. ",
"_____no_output_____"
]
],
[
[
"from mhkit.wave.io import swan\nimport matplotlib.pyplot as plt\nfrom os.path import join\nimport pandas as pd\n\nswan_data_folder = join('data','wave','swan')",
"_____no_output_____"
]
],
[
[
"## Supported SWAN Output Files\n\nMHKiT currenlty supports block and table SWAN output files in ASCII or binary (*.mat) files. Detailed descriptions of these file types may be found in the [SWAN User Manual](http://swanmodel.sourceforge.net/download/zip/swanuse.pdf). In the following cells, SWAN table and block data will be imported, discussed, and plotted. Three SWAN output files will be imported:\n 1. An ASCII table file ('SWANOUT.DAT'), \n 2. An ASCII block file ('SWANOUTBlock.DAT') \n 3. A binary block file ('SWANOUT.mat') ",
"_____no_output_____"
]
],
[
[
"swan_table_file = join(swan_data_folder, 'SWANOUT.DAT')\nswan_block_file = join(swan_data_folder, 'SWANOUTBlock.DAT')\nswan_block_mat_file = join(swan_data_folder, 'SWANOUT.mat')",
"_____no_output_____"
]
],
[
[
"## Load SWAN Files with MHKiT\n\nTo load a supported SWAN file simply call the `swan.read_table` or `swan.read_block` as appropriate for the swan output. The MHKiT function will read in the SWAN output and return the data as a DataFrame for table data or a dictionary of DataFrames for block data with multiple quantities of interest written to the file. The MHKiT SWAN read function will also return any metadata that the file may contain which will vary based on the file type and options specified in the SWAN run. MHKiT requires that for block data written in ASCII format that the file was written with headers. The `swan.read_block` function accepts both binary and ASCII format by assuming that any non-'.mat' extension is ASCII format.",
"_____no_output_____"
],
[
"## SWAN Table Data and Metadata\n\nThe SWAN output table is parsed from the MHKiT funtion `swan.read_table` into a DataFrame that is displayed below. The DataFrame columns contain a series of x-points ('Xp'), y-points ('Yp'), and keyword values at a given (x,y) point. The keywords are specified in the SWAN user manual and here can be seen as: 'Hsig' (significant wave height), 'Dir' (average wave direction), 'RTpeak' (Relative peak period), 'TDir' (direction of the energy transport). ",
"_____no_output_____"
]
],
[
[
"swan_table, metadata_table = swan.read_table(swan_table_file)\nswan_table",
"_____no_output_____"
]
],
[
[
"In the cell below, metadata is written to screen and can be seen to be a dictionary of keywords which contains the SWAN run name, the type of table written, the version of SWAN run, the column headers, and the associated units.",
"_____no_output_____"
]
],
[
[
"metadata_table",
"_____no_output_____"
]
],
[
[
"## SWAN Block (ASCII) Data and Metadata\n\nMHKiT will read in block data as a Dictionary of DataFrames for each quantity of interest in the file. The Dictionary `swan_block` (shown below) is read using `swan.read_block` on the ASCII block data, and has the same four keys from the table data shown previously. In the cell below the DataFrame for the 'Significant wave height' is shown by accessing the Dictionary using the specified key. This DataFrame has indices and columns referring to a point on the grid and a value of significant wave height at each point. In the last code block, the metadata Dictionary is written to screen.",
"_____no_output_____"
]
],
[
[
"swan_block, metadata_block = swan.read_block(swan_block_file)\nswan_block.keys()",
"_____no_output_____"
],
[
"swan_block['Significant wave height']",
"_____no_output_____"
],
[
"metadata_block",
"_____no_output_____"
]
],
[
[
"## SWAN Block (.mat) Data and Metadata\n\nThe Block \"SWANOUT.mat\" file is a binary output from SWAN containing the same data as was shown for the ASCII block file above. The Dictionary `swan_block_mat` (shown below) is read using `swan.read_block` on the binary block data, and has the same four keys from the Table data shown previously. Looking at the first code block below it can be seen that the returned Dictionary keys are the SWAN variable names ('Hsig', 'Dir', 'RTpeak', 'TDir'). Looking at the DataFrame for the significant wave height ('Hsig') we can see that the indices and columns are the same as the previous block ASCII DataFrame but the values now contain six decimal places. One consideration for working with binary data is shown in the last cell block of the section where there is no metadata letting the user know the units of the data. For binary data, the user would need to check the run's SWAN input file.",
"_____no_output_____"
]
],
[
[
"swan_block_mat, metadata_block_mat = swan.read_block(swan_block_mat_file)\nswan_block_mat.keys()",
"_____no_output_____"
],
[
"swan_block_mat['Hsig']",
"_____no_output_____"
],
[
"metadata_block_mat",
"_____no_output_____"
]
],
[
[
"## Block to Table\n\nMHKiT provides functionality to convert SWAN block Dictionaries to table DataFrame format. This provides the user with the ability to easily process and manipulate data across multiple data types. The function converts each key to a column in a single DataFrame.",
"_____no_output_____"
]
],
[
[
"swan_block_as_table = swan.dictionary_of_block_to_table(swan_block)\nswan_block_mat_as_table = swan.dictionary_of_block_to_table(swan_block_mat)\nswan_block_as_table",
"_____no_output_____"
]
],
[
[
"## Example Plots from SWAN Data\n\nThis last section shows a couple of plots for the significant wave height using each of the imported results.",
"_____no_output_____"
]
],
[
[
"plt.figure()\nplt.tricontourf(swan_table.Xp, swan_table.Yp, \n swan_table.Hsig, levels=256)\ncbar = plt.colorbar()\ncbar.set_label('Significant wave height [m]')",
"_____no_output_____"
],
[
"plt.figure()\nplt.tricontourf(swan_block_mat_as_table.x, swan_block_mat_as_table.y, \n swan_block_mat_as_table.Hsig,\n levels=256, cmap='viridis')\ncbar = plt.colorbar()\ncbar.set_label('Significant wave height [m]')",
"_____no_output_____"
],
[
"plt.figure()\nplt.tricontourf(swan_block_as_table.x, swan_block_as_table.y, \n swan_block_as_table['Significant wave height'], \n levels=256, cmap='viridis')\ncbar = plt.colorbar()\ncbar.set_label('Significant wave height [m]')",
"_____no_output_____"
]
],
[
[
"## Plot Block Data\n\nLastly significant wave height is plotted from the block data using `imshow` with a reversed y-axis to show the same plot achieved above.",
"_____no_output_____"
]
],
[
[
"plt.figure()\nplt.imshow(swan_block_mat['Hsig'])\nplt.gca().invert_yaxis()\ncbar = plt.colorbar()\ncbar.set_label('Significant wave height [m]')",
"_____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",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
]
] |
ece81604e39c41668426702675bbc2fcfb881b4b | 45,857 | ipynb | Jupyter Notebook | docs/tutorials/03-kglab_pytorch_geometric.ipynb | issam9/rubrix | 16cafb10ca60bb75dd716a33eb8e5149bdbedb7b | [
"Apache-2.0"
] | 5 | 2021-11-11T23:37:53.000Z | 2021-12-19T03:09:43.000Z | docs/tutorials/03-kglab_pytorch_geometric.ipynb | issam9/rubrix | 16cafb10ca60bb75dd716a33eb8e5149bdbedb7b | [
"Apache-2.0"
] | null | null | null | docs/tutorials/03-kglab_pytorch_geometric.ipynb | issam9/rubrix | 16cafb10ca60bb75dd716a33eb8e5149bdbedb7b | [
"Apache-2.0"
] | 1 | 2022-02-11T08:28:02.000Z | 2022-02-11T08:28:02.000Z | 28.57134 | 419 | 0.561223 | [
[
[
"# 🧪 Node classification with `kglab` and PyTorch Geometric\n\nWe introduce the application of neural networks on knowledge graphs using `kglab` and `pytorch_geometric`. \n\nGraph Neural networks (GNNs) have gained popularity in a number of practical applications, including knowledge graphs, social networks and recommender systems. In the context of knowledge graphs, GNNs are being used for tasks such as link prediction, node classification or knowledge graph embeddings. Many use cases for these tasks are related to `Automatic Knowledge Base Construction` (AKBC) and completion.\n\nIn this tutorial, we will learn to:\n\n- use `kglab` to represent a knowledge graph as a Pytorch Tensor, a suitable structure for working with neural nets\n\n- use the widely known `pytorch_geometric` (PyG) GNN library together with `kglab`.\n\n- train a GNN with `pytorch_geometric` and `PyTorch Lightning` for semi-supervised node classification of the recipes knowledge graph.\n\n- build and iterate on training data using `rubrix` with a Human-in-the-loop (HITL) approach.\n\n## Our use case in a nutshell\n\nOur goal in this notebook will be to build a semi-supervised node classifier of recipes and ingredients from scratch using kglab, PyG and Rubrix. \n\nOur classifier will be able to classify the nodes in our 15K nodes knowledge graph according to a set of pre-defined flavour related categories: `sweet`, `salty`, `piquant`, `sour`, etc. To account for mixed flavours (e.g., sweet chili sauce), our model will be multi-class (we have several target labels), multi-label (a node can be labelled as with 0 or several categories).",
"_____no_output_____"
],
[
"## Install `kglab` and `Pytorch Geometric`",
"_____no_output_____"
]
],
[
[
"%pip install torch-scatter -f https://pytorch-geometric.com/whl/torch-1.8.0+cpu.html -qqq\n%pip install torch-sparse -f https://pytorch-geometric.com/whl/torch-1.8.0+cpu.html -qqq\n%pip install torch-cluster -f https://pytorch-geometric.com/whl/torch-1.8.0+cpu.html -qqq\n%pip install torch-spline-conv -f https://pytorch-geometric.com/whl/torch-1.8.0+cpu.html -qqq\n%pip install torch-geometric -qqq\n%pip install torch==1.8.0 -qqq\n\n%pip install kglab -qqq\n\n%pip install pytorch_lightning -qqq",
"_____no_output_____"
]
],
[
[
"## 1. Loading and exploring the recipes knowledge graph\n\nWe'll be working with the \"recipes\" knowledge graph, which is used throughout the `kglab` tutorial (see the [Syllabus](https://derwen.ai/docs/kgl/tutorial/)).\n\nThis version of the recipes kg contains around ~15K recipes linked to their respective ingredients, as well as some other properties such as cooking time, labels and descriptions. \n\nLet's load the knowledge graph into a `kg` object by reading from an RDF file (in Turtle):",
"_____no_output_____"
]
],
[
[
"import kglab\n\nNAMESPACES = {\n \"wtm\": \"http://purl.org/heals/food/\",\n \"ind\": \"http://purl.org/heals/ingredient/\",\n \"recipe\": \"https://www.food.com/recipe/\",\n }\n\nkg = kglab.KnowledgeGraph(namespaces = NAMESPACES)\n\n_ = kg.load_rdf(\"data/recipe_lg.ttl\")",
"_____no_output_____"
]
],
[
[
"Let's take a look at our graph structure using the `Measure` class:",
"_____no_output_____"
]
],
[
[
"measure = kglab.Measure()\nmeasure.measure_graph(kg)\n\nf\"Nodes: {measure.get_node_count()} ; Edges: {measure.get_edge_count()}\"",
"_____no_output_____"
],
[
"measure.p_gen.get_tally() # tallies the counts of predicates",
"_____no_output_____"
],
[
"measure.s_gen.get_tally() # tallies the counts of predicates",
"_____no_output_____"
],
[
"measure.o_gen.get_tally() # tallies the counts of predicates",
"_____no_output_____"
],
[
"measure.l_gen.get_tally() # tallies the counts of literals",
"_____no_output_____"
]
],
[
[
"From the above exploration, we can extract some conclusions to guide the next steps:\n\n- We have a limited number of relationships, being `hasIngredient` the most frequent.\n\n- We have rather unique literals for labels and descriptions, but a certain amount of repetition for `hasCookTime`.\n\n- As we would have expected, most frequently referenced objects are ingredients such as `Salt`, `ChikenEgg` and so on. \n\n\nNow, let's move into preparing our knowledge graph for PyTorch.",
"_____no_output_____"
],
[
"## 2. Representing our knowledge graph as a `PyTorch` Tensor\n\nLet's now represent our `kg` as a `PyTorch` tensor using the `kglab.SubgraphTensor` class.",
"_____no_output_____"
]
],
[
[
"sg = kglab.SubgraphTensor(kg)",
"_____no_output_____"
],
[
"def to_edge_list(g, sg, excludes):\n def exclude(rel):\n return sg.n3fy(rel) in excludes\n \n relations = sorted(set(g.predicates()))\n subjects = set(g.subjects())\n objects = set(g.objects())\n nodes = list(subjects.union(objects))\n \n relations_dict = {rel: i for i, rel in enumerate(list(relations)) if not exclude(rel)}\n \n # this offset enables consecutive indices in our final vector\n offset = len(relations_dict.keys())\n \n nodes_dict = {node: i+offset for i, node in enumerate(nodes)}\n\n \n edge_list = []\n \n for s, p, o in g.triples((None, None, None)):\n if p in relations_dict.keys(): # this means is not excluded\n src, dst, rel = nodes_dict[s], nodes_dict[o], relations_dict[p]\n edge_list.append([src, dst, 2 * rel])\n edge_list.append([dst, src, 2 * rel + 1])\n \n # turn into str keys and concat\n node_vector = [sg.n3fy(node) for node in relations_dict.keys()] + [sg.n3fy(node) for node in nodes_dict.keys()]\n return edge_list, node_vector",
"_____no_output_____"
],
[
"edge_list, node_vector = to_edge_list(kg.rdf_graph(), sg, excludes=['skos:description', 'skos:prefLabel'])",
"_____no_output_____"
],
[
"len(edge_list) , edge_list[0:5]",
"_____no_output_____"
]
],
[
[
"Let's create `kglab.Subgraph` to be used for encoding/decoding numerical ids and uris, which will be useful for preparing our training data, as well as making sense of the predictions of our neural net.",
"_____no_output_____"
]
],
[
[
"sg = kglab.Subgraph(kg=kg, preload=node_vector)",
"_____no_output_____"
],
[
"import torch\nfrom torch_geometric.data import Data\n\ntensor = torch.tensor(edge_list, dtype=torch.long).t().contiguous() \nedge_index, edge_type = tensor[:2], tensor[2]\ndata = Data(edge_index=edge_index)\ndata.edge_type = edge_type",
"_____no_output_____"
],
[
"(data.edge_index.shape, data.edge_type.shape, data.edge_type.max())",
"_____no_output_____"
]
],
[
[
"## 3. Building a training set with Rubrix\n\nNow that we have a tensor representation of our kg which we can feed into our neural network, let's now focus on the training data.\n\nAs we will be doing semi-supervised classification, we need to build a training set (i.e., some recipes and ingredients with ground-truth labels). \n\n\nFor this, we can use [Rubrix](https://github.com/recognai/rubrix), an open-source tool for exploring, labeling and iterating on data for AI. Rubrix allows data scientists and subject matter experts to rapidly iterate on training and evaluation data by enabling iterative, asynchronous and potentially distributed workflows.\n\nIn Rubrix, a very simple workflow during model development looks like this:\n\n1. Log unlabelled data records with `rb.log()` into a Rubrix dataset. At this step you could use weak supervision methods (e.g., Snorkel) to pre-populate and then only refine the suggested labels, or use a pretrained model to guide your annotation process. In our case, we will just log recipe and ingredient \"records\" along with some metadata (RDF types, labels, etc.).\n\n2. Rapidly explore and label records in your dataset using the webapp which follows a search-driven approach, which is especially useful with large, potentially noisy datasets and for quickly leveraging domain knowledge (e.g., recipes containing WhiteSugar are likely sweet). For the tutorial, we have spent around 30min for labelling around 600 records.\n\n3. Retrieve your annotations any time using `rb.load()`, which return a convenient `pd.Dataframe` making it quite handy to process and use for model development. In our case, we will load a dataset, filter annotated entities, do a train_test_split with scikit_learn, and then use this for training our GNN.\n\n4. After training a model, you can go back to step 1, this time using your model and its predictions, to spot improvements, quickly label other portions of the data, and so on. In our case, as we've started with a very limited training set (~600 examples), we will use our node classifier and `rb.log()` it's predictions over the rest of our data (unlabelled recipes and ingredients).",
"_____no_output_____"
]
],
[
[
"LABELS = ['Bitter', 'Meaty', 'Piquant', 'Salty', 'Sour', 'Sweet']",
"_____no_output_____"
]
],
[
[
"### Setup Rubrix\n\nIf you have not installed and launched Rubrix, check the [installation guide](https://github.com/recognai/rubrix#get-started). ",
"_____no_output_____"
]
],
[
[
"import rubrix as rb",
"_____no_output_____"
]
],
[
[
"### Preparing our raw dataset of recipes and ingredients",
"_____no_output_____"
]
],
[
[
"import pandas as pd\nsparql = \"\"\"\n SELECT distinct *\n WHERE {\n ?uri a wtm:Recipe .\n ?uri a ?type .\n ?uri skos:definition ?definition .\n ?uri wtm:hasIngredient ?ingredient\n } \n\"\"\"\ndf = kg.query_as_df(sparql=sparql)\n\n# We group the ingredients into one column containing lists:\nrecipes_df = df.groupby(['uri', 'definition', 'type'])['ingredient'].apply(list).reset_index(name='ingredients') ; recipes_df\n\nsparql_ingredients = \"\"\"\n SELECT distinct *\n WHERE {\n ?uri a wtm:Ingredient .\n ?uri a ?type .\n OPTIONAL { ?uri skos:prefLabel ?definition } \n }\n\"\"\"\n\ndf = kg.query_as_df(sparql=sparql_ingredients)\ndf['ingredients'] = None\n\ning_recipes_df = pd.concat([recipes_df, df]).reset_index(drop=True)\n\ning_recipes_df.fillna('', inplace=True) ; ing_recipes_df",
"_____no_output_____"
]
],
[
[
"### Logging into Rubrix",
"_____no_output_____"
]
],
[
[
"import rubrix as rb\n\nrecords = []\nfor i, r in ing_recipes_df.iterrows():\n item = rb.TextClassificationRecord(\n inputs={\n \"id\":r.uri, \n \"definition\": r.definition,\n \"ingredients\": str(r.ingredients), \n \"type\": r.type\n }, # log node fields\n prediction=[(label, 0.0) for label in LABELS], # log \"dummy\" predictions for aiding annotation\n metadata={'ingredients': [ing.replace('ind:','') for ing in r.ingredients], \"type\": r.type}, # metadata filters for quick exploration and annotation\n prediction_agent=\"kglab_tutorial\", # who's performing/logging the prediction\n multi_label=True\n )\n records.append(item)",
"_____no_output_____"
],
[
"len(records)",
"_____no_output_____"
],
[
"rb.log(records=records, name=\"kg_classification_tutorial\")",
"_____no_output_____"
]
],
[
[
"### Annotation session with Rubrix (optional)\n\nIn this step you can go to your rubrix dataset and annotate some examples of each class.\n\nIf you have no time to do this, just skip this part as we have prepared a dataset for you with around ~600 examples.",
"_____no_output_____"
],
[
"### Loading our labelled records and create a train_test split (optional)\n\nIf you have no time to do this, just skip this part as we have prepared a dataset for you.",
"_____no_output_____"
]
],
[
[
"rb.snapshots(name=\"kg_classification_tutorial\")",
"_____no_output_____"
]
],
[
[
"Once you have annotated your dataset, you will find an snapshot id on the previous list. This id should be place in the next command. In our case, it was 1620136587.907149.",
"_____no_output_____"
]
],
[
[
"df = rb.load(name=\"kg_classification_tutorial\", snapshot='1620136587.907149') ; df.head()",
"_____no_output_____"
],
[
"from sklearn.model_selection import train_test_split\n\ntrain_df, test_df = train_test_split(df)\ntrain_df.to_csv('data/train_recipes_new.csv')\ntest_df.to_csv('data/test_recipes_new.csv')",
"_____no_output_____"
]
],
[
[
"### Creating PyTorch train and test sets\n\nHere we take our train and test datasets and transform them into `torch.Tensor` objects with the help of our kglab `Subgraph` for turning `uris` into `torch.long` indices.",
"_____no_output_____"
]
],
[
[
"import pandas as pd\n\ntrain_df = pd.read_csv('data/train_recipes.csv') # use your own labelled datasets if you've created a snapshot\ntest_df = pd.read_csv('data/test_recipes.csv')\n\n# we make sure lists are parsed correctly\ntrain_df.labels = train_df.labels.apply(eval)\ntest_df.labels = test_df.labels.apply(eval)",
"_____no_output_____"
],
[
"train_df",
"_____no_output_____"
]
],
[
[
"Let's create label lookups for label to int and viceversa",
"_____no_output_____"
]
],
[
[
"label2id = {label:i for i,label in enumerate(LABELS)} ; \nid2label = {i:l for l,i in label2id.items()} ; (id2label, label2id)",
"_____no_output_____"
]
],
[
[
"The following function turns our DataFrame into numerical arrays for node indices and labels",
"_____no_output_____"
]
],
[
[
"import numpy as np\n\ndef create_indices_labels(df):\n # turn our dense labels into a one-hot list\n def one_hot(label_ids):\n a = np.zeros(len(LABELS))\n a.put(label_ids, np.ones(len(label_ids)))\n return a\n \n indices, labels = [], []\n for uri, label in zip(df.uri.tolist(), df.labels.tolist()):\n indices.append(sg.transform(uri))\n labels.append(one_hot([label2id[label] for label in label]))\n return indices, labels",
"_____no_output_____"
]
],
[
[
"Finally, let's turn our dataset into PyTorch tensors",
"_____no_output_____"
]
],
[
[
"train_indices, train_labels = create_indices_labels(train_df)\ntest_indices, test_labels = create_indices_labels(test_df)\n\ntrain_idx = torch.tensor(train_indices, dtype=torch.long)\ntrain_y = torch.tensor(train_labels, dtype=torch.float)\n\ntest_idx = torch.tensor(test_indices, dtype=torch.long)\ntest_y = torch.tensor(test_labels, dtype=torch.float) ; train_idx[:10], train_y",
"_____no_output_____"
]
],
[
[
"Let's see if we can recover the correct URIs for our numerical ids using our `kglab.Subgraph`",
"_____no_output_____"
]
],
[
[
"(train_df.loc[0], sg.inverse_transform(15380))",
"_____no_output_____"
]
],
[
[
"## 4. Creating a Subgraph of recipe and ingredient nodes\nHere we create a node list to be used as a seed for building our `PyG` subgraph (using k-hops as we will see in the next section). Our goal will be to start only with `recipes` and `ingredients`, as all nodes passed through the GNN will be classified and those are our main target. ",
"_____no_output_____"
]
],
[
[
"node_idx = torch.LongTensor([\n sg.transform(i) for i in ing_recipes_df.uri.values\n])",
"_____no_output_____"
],
[
"node_idx.max(), node_idx.shape",
"_____no_output_____"
],
[
"ing_recipes_df.iloc[1]",
"_____no_output_____"
],
[
"sg.inverse_transform(node_idx[1])",
"_____no_output_____"
],
[
"node_idx[0:10]",
"_____no_output_____"
]
],
[
[
"## 5. Semi-supervised node classification with PyTorch Geometric\n\nFor the node classification task **we are given the ground-truth labels** (our recipes and ingredients training set) **for a small subset of nodes**, and **we want to predict the labels for all the remaining nodes** (our recipes and ingredients test set and unlabelled nodes).\n\n\n### Graph Convolutional Networks\n\nTo get a great intro to GCNs we recommend you to check Kipf's [blog post](https://tkipf.github.io/graph-convolutional-networks/) on the topic. \n\nIn a nutshell, GCNs are multi-layer neural works which apply \"convolutions\" to nodes in graphs by sharing and applying the same filter parameters over all locations in the graph. \n\nAdditionally, modern GCNs such as those implemented in `PyG` use **message passing** mechanisms, where vertices exchange information with their neighbors, and send messages to each other.\n\n![GCN_Kipf](img/gcn_web.png \"GCN\")\n\n***Multi-layer Graph Convolutional Network (GCN) with first-order filters***. Source: https://tkipf.github.io/graph-convolutional-networks\n\n### Relational Graph Convolutional Networks\n\nRelational Graph Convolutional Networks (R-GCNs) were introduced by [Schlichtkrull et al. 2017](https://arxiv.org/abs/1703.06103), as an extension of GCNs to deal with **multi-relational knowledge graphs**. \n\nYou can see below the computation model for nodes:",
"_____no_output_____"
],
[
"![RGCN](img/rgcn.png \"RGCN\")\n\n***Computation of the update of a single graph node(red) in the R-GCN model.***. Source: https://arxiv.org/abs/1703.06103",
"_____no_output_____"
],
[
"### Creating a `PyG` subgraph\n\nHere we build a subgraph with `k` hops from target to source starting with all `recipe` and `ingredient` nodes:",
"_____no_output_____"
]
],
[
[
"from torch_geometric.utils import k_hop_subgraph\n# here we take all connected nodes with k hops\nk = 1\nnode_idx, edge_index, mapping, edge_mask = k_hop_subgraph(\n node_idx, \n k, \n data.edge_index, \n relabel_nodes=False\n)",
"_____no_output_____"
]
],
[
[
"We have increased the size of our node set:",
"_____no_output_____"
]
],
[
[
"node_idx.shape",
"_____no_output_____"
],
[
"data.edge_index.shape",
"_____no_output_____"
]
],
[
[
"Here we compute some measures needed for defining the size of our layers",
"_____no_output_____"
]
],
[
[
"data.edge_index = edge_index\n\ndata.num_nodes = data.edge_index.max().item() + 1\n\ndata.num_relations = data.edge_type.max().item() + 1\n\ndata.edge_type = data.edge_type[edge_mask]\n\ndata.num_classes = len(LABELS)\n\ndata.num_nodes, data.num_relations, data.num_classes",
"_____no_output_____"
]
],
[
[
"### Defining a basic Relational Graph Convolutional Network",
"_____no_output_____"
]
],
[
[
"from torch_geometric.nn import FastRGCNConv, RGCNConv\nimport torch.nn.functional as F",
"_____no_output_____"
],
[
"RGCNConv?",
"_____no_output_____"
],
[
"class RGCN(torch.nn.Module):\n def __init__(self, num_nodes, num_relations, num_classes, out_channels=16, num_bases=30, dropout=0.0, layer_type=FastRGCNConv, ):\n \n super(RGCN, self).__init__()\n \n self.conv1 = layer_type(\n num_nodes, \n out_channels, \n num_relations, \n num_bases=num_bases\n )\n self.conv2 = layer_type(\n out_channels, \n num_classes, \n num_relations, \n num_bases=num_bases\n )\n self.dropout = torch.nn.Dropout(dropout)\n\n def forward(self, edge_index, edge_type):\n x = F.relu(self.conv1(None, edge_index, edge_type))\n x = self.dropout(x)\n x = self.conv2(x, edge_index, edge_type)\n return torch.sigmoid(x)",
"_____no_output_____"
]
],
[
[
"### Create and visualizing our model",
"_____no_output_____"
]
],
[
[
"model = RGCN(\n num_nodes=data.num_nodes,\n num_relations=data.num_relations,\n num_classes=data.num_classes,\n #out_channels=64,\n dropout=0.2,\n layer_type=RGCNConv\n) ; model",
"_____no_output_____"
],
[
"# code adapted from https://colab.research.google.com/drive/14OvFnAXggxB8vM4e8vSURUp1TaKnovzX\n%matplotlib inline\nimport matplotlib.pyplot as plt\nfrom sklearn.manifold import TSNE\nfrom pytorch_lightning.metrics.utils import to_categorical\n\ndef visualize(h, color, labels):\n z = TSNE(n_components=2).fit_transform(h.detach().cpu().numpy())\n\n plt.figure(figsize=(10,10))\n plt.xticks([])\n plt.yticks([])\n \n scatter = plt.scatter(z[:, 0], z[:, 1], s=70, c=color, cmap=\"Set2\")\n legend = plt.legend(scatter.legend_elements()[0],labels, loc=\"upper right\", title=\"Labels\",) #*scatter.legend_elements()\n plt.show()",
"_____no_output_____"
],
[
"pred = model(edge_index, edge_type)",
"_____no_output_____"
],
[
"visualize(pred[train_idx], color=to_categorical(train_y), labels=LABELS)",
"_____no_output_____"
],
[
"visualize(pred[test_idx], color=to_categorical(test_y), labels=LABELS)",
"_____no_output_____"
]
],
[
[
"### Training our RGCN",
"_____no_output_____"
]
],
[
[
"device = torch.device('cpu') # ('cuda')\ndata = data.to(device)\nmodel = model.to(device)\noptimizer = torch.optim.AdamW(model.parameters())\nloss_module = torch.nn.BCELoss()\n\ndef train():\n model.train()\n optimizer.zero_grad()\n out = model(data.edge_index, data.edge_type)\n loss = loss_module(out[train_idx], train_y)\n loss.backward()\n optimizer.step()\n return loss.item()\n\ndef accuracy(predictions, y):\n predictions = np.round(predictions)\n return predictions.eq(y).to(torch.float).mean()\n\[email protected]_grad()\ndef test():\n model.eval()\n pred = model(data.edge_index, data.edge_type)\n train_acc = accuracy(pred[train_idx], train_y)\n test_acc = accuracy(pred[test_idx], test_y)\n return train_acc.item(), test_acc.item()",
"_____no_output_____"
],
[
"for epoch in range(1, 50):\n loss = train()\n train_acc, test_acc = test()\n print(f'Epoch: {epoch:02d}, Loss: {loss:.4f}, Train: {train_acc:.4f} '\n f'Test: {test_acc:.4f}')",
"_____no_output_____"
]
],
[
[
"### Model visualization",
"_____no_output_____"
]
],
[
[
"pred = model(edge_index, edge_type)",
"_____no_output_____"
],
[
"visualize(pred[train_idx], color=to_categorical(train_y), labels=LABELS)",
"_____no_output_____"
],
[
"visualize(pred[test_idx], color=to_categorical(test_y), labels=LABELS)",
"_____no_output_____"
]
],
[
[
"## 6. Using our model and analyzing its predictions with Rubrix\nLet's see the shape of our model predictions",
"_____no_output_____"
]
],
[
[
"pred = model(edge_index, edge_type) ; pred",
"_____no_output_____"
],
[
"def find(tensor, values):\n return torch.nonzero(tensor[..., None] == values)",
"_____no_output_____"
]
],
[
[
"### Analizing predictions over the test set",
"_____no_output_____"
]
],
[
[
"test_idx = find(node_idx,test_idx)[:,0] ; len(test_idx)",
"_____no_output_____"
],
[
"index = torch.zeros(node_idx.shape[0], dtype=bool)\nindex[test_idx] = True\nidx = node_idx[index]",
"_____no_output_____"
],
[
"uris = [sg.inverse_transform(i) for i in idx]\npredicted_labels = [l for l in pred[idx]]",
"_____no_output_____"
],
[
"predictions = list(zip(uris,predicted_labels)) ; predictions[0:2]",
"_____no_output_____"
],
[
"import rubrix as rb\n\nrecords = []\nfor uri,predicted_labels in predictions:\n ids = ing_recipes_df.index[ing_recipes_df.uri == uri]\n if len(ids) > 0:\n r = ing_recipes_df.iloc[ids]\n # get the gold labels from our test set\n gold_labels = test_df.iloc[test_df.index[test_df.uri == uri]].labels.values[0]\n \n item = rb.TextClassificationRecord(\n inputs={\"id\":r.uri.values[0], \"definition\": r.definition.values[0], \"ingredients\": str(r.ingredients.values[0]), \"type\": r.type.values[0]}, \n prediction=[(id2label[i], score) for i,score in enumerate(predicted_labels)],\n annotation=gold_labels,\n metadata={'ingredients': r.ingredients.values[0], \"type\": r.type.values[0]}, \n prediction_agent=\"node_classifier_v1\", \n multi_label=True\n )\n records.append(item)",
"_____no_output_____"
],
[
"rb.log(records, name=\"kg_classification_test_analysis\")",
"_____no_output_____"
]
],
[
[
"### Analizing predictions over unseen nodes (and potentially relabeling them)",
"_____no_output_____"
],
[
"Let's find the ids for the nodes in our training and test sets",
"_____no_output_____"
]
],
[
[
"train_test_idx = find(node_idx,torch.cat((test_idx, train_idx)))[:,0] ; len(train_test_idx)",
"_____no_output_____"
]
],
[
[
"Let's get the ids, uris and labels of the nodes which were not in our train/test datasets",
"_____no_output_____"
]
],
[
[
"index = torch.ones(node_idx.shape[0], dtype=bool)\nindex[train_test_idx] = False\nidx = node_idx[index]",
"_____no_output_____"
]
],
[
[
"We use our `SubgraphTensor` for getting back our URIs and build `uri,predicted_labels` pairs:",
"_____no_output_____"
]
],
[
[
"uris = [sg.inverse_transform(i) for i in idx]\npredicted_labels = [l for l in pred[idx]]",
"_____no_output_____"
],
[
"predictions = list(zip(uris,predicted_labels)) ; predictions[0:2]",
"_____no_output_____"
],
[
"import rubrix as rb\n\nrecords = []\nfor uri,predicted_labels in predictions:\n ids = ing_recipes_df.index[ing_recipes_df.uri == uri]\n if len(ids) > 0:\n r = ing_recipes_df.iloc[ids]\n item = rb.TextClassificationRecord(\n inputs={\"id\":r.uri.values[0], \"definition\": r.definition.values[0], \"ingredients\": str(r.ingredients.values[0]), \"type\": r.type.values[0]}, \n prediction=[(id2label[i], score) for i,score in enumerate(predicted_labels)], \n metadata={'ingredients': r.ingredients.values[0], \"type\": r.type.values[0]}, \n prediction_agent=\"node_classifier_v1\", \n multi_label=True\n )\n records.append(item)",
"_____no_output_____"
],
[
"rb.log(records, name=\"kg_node_classification_unseen_nodes_v3\")",
"_____no_output_____"
]
],
[
[
"## Exercise 1: Training experiments with PyTorch Lightning",
"_____no_output_____"
]
],
[
[
"#!pip install wandb -qqq # optional",
"_____no_output_____"
],
[
"!wandb login #optional",
"_____no_output_____"
],
[
"from torch_geometric.data import Data, DataLoader\n\ndata.train_idx = train_idx\ndata.train_y = train_y\ndata.test_idx = test_idx\ndata.test_y = test_y\n\ndataloader = DataLoader([data], batch_size=1); dataloader",
"_____no_output_____"
],
[
"import torch\nimport pytorch_lightning as pl\nfrom pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint\nfrom pytorch_lightning.loggers import WandbLogger\n\nclass RGCNNodeClassification(pl.LightningModule):\n \n def __init__(self, **model_kwargs):\n super().__init__()\n \n self.model = RGCN(**model_kwargs)\n self.loss_module = torch.nn.BCELoss()\n \n def forward(self, edge_index, edge_type):\n return self.model(edge_index, edge_type)\n \n def configure_optimizers(self):\n optimizer = torch.optim.Adam(self.parameters(), lr=0.01, weight_decay=0.001)\n return optimizer\n \n def training_step(self, batch, batch_idx):\n idx, y = data.train_idx, data.train_y\n edge_index, edge_type = data.edge_index, data.edge_type\n x = self.forward(edge_index, edge_type)\n loss = self.loss_module(x[idx], y)\n x = x.detach()\n self.log('train_acc', accuracy(x[idx], y), prog_bar=True)\n self.log('train_loss', loss)\n return loss \n \n def validation_step(self, batch, batch_idx):\n idx, y = data.test_idx, data.test_y\n edge_index, edge_type = data.edge_index, data.edge_type\n x = self.forward(edge_index, edge_type)\n loss = self.loss_module(x[idx], y)\n x = x.detach()\n self.log('val_acc', accuracy(x[idx], y), prog_bar=True)\n self.log('val_loss', loss)",
"_____no_output_____"
],
[
"pl.seed_everything()",
"_____no_output_____"
],
[
"model_pl = RGCNNodeClassification(\n num_nodes=data.num_nodes,\n num_relations=data.num_relations,\n num_classes=data.num_classes,\n #out_channels=64,\n dropout=0.2,\n #layer_type=RGCNConv\n)",
"_____no_output_____"
],
[
"early_stopping = EarlyStopping(monitor='val_acc', patience=10, mode='max')",
"_____no_output_____"
],
[
"trainer = pl.Trainer(\n default_root_dir='pl_runs',\n checkpoint_callback=ModelCheckpoint(save_weights_only=True, mode=\"max\", monitor=\"val_acc\"),\n max_epochs=200,\n #logger= WandbLogger(), # optional\n callbacks=[early_stopping]\n)",
"_____no_output_____"
],
[
"trainer.fit(model_pl, dataloader, dataloader)",
"_____no_output_____"
]
],
[
[
"## Exercise 2: Bootstrapping annotation with a zeroshot-classifier",
"_____no_output_____"
]
],
[
[
"!pip install transformers -qqq",
"_____no_output_____"
],
[
"from transformers import pipeline\n \npretrained_model = \"valhalla/distilbart-mnli-12-1\" # \"typeform/squeezebert-mnli\"\n\npl = pipeline('zero-shot-classification', model=pretrained_model)",
"_____no_output_____"
],
[
"pl(\"chocolate cake\", LABELS, hypothesis_template='The flavour is {}.',multi_label=True)",
"_____no_output_____"
],
[
"import rubrix as rb\n\nrecords = []\nfor i, r in ing_recipes_df[50:150].iterrows():\n preds = pl(r.definition, LABELS, hypothesis_template='The flavour is {}.', multi_label=True)\n item = rb.TextClassificationRecord(\n inputs={\n \"id\":r.uri, \n \"definition\": r.definition,\n \"ingredients\": str(r.ingredients), \n \"type\": r.type\n }, \n prediction=list(zip(preds['labels'], preds['scores'])), # TODO: here we log he predictions of our zeroshot pipeline as a list of tuples (label, score)\n metadata={'ingredients': r.ingredients, \"type\": r.type}, \n prediction_agent=\"valhalla/distilbart-mnli-12-1\", \n multi_label=True\n )\n records.append(item)",
"_____no_output_____"
],
[
"rb.log(records, name='kg_zeroshot')",
"_____no_output_____"
]
],
[
[
"## Next steps\n\n### 📚 [Rubrix documentation](https://docs.rubrix.ml) for more guides and tutorials.\n\n### 🙋♀️ Join the Rubrix community! A good place to start is the [discussion forum](https://github.com/recognai/rubrix/discussions).\n\n### ⭐ Rubrix [Github repo](https://github.com/recognai/rubrix) to stay updated.",
"_____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"
] | [
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
]
] |
ece8235fbcdd2217a23644426a819bd5071b68ed | 283,442 | ipynb | Jupyter Notebook | EHR_Only/Lasso/Comp Cardio.ipynb | shreyaskar123/EHR-Discontinuity | 8d2becfd784b9cbe697f8308d60023701971ef5d | [
"MIT"
] | null | null | null | EHR_Only/Lasso/Comp Cardio.ipynb | shreyaskar123/EHR-Discontinuity | 8d2becfd784b9cbe697f8308d60023701971ef5d | [
"MIT"
] | null | null | null | EHR_Only/Lasso/Comp Cardio.ipynb | shreyaskar123/EHR-Discontinuity | 8d2becfd784b9cbe697f8308d60023701971ef5d | [
"MIT"
] | null | null | null | 15.671901 | 1,735 | 0.29334 | [
[
[
"import pandas as pd\nmedicare = pd.read_csv(\"/netapp2/home/se197/RPDR/Josh Lin/3_EHR_V2/CMS/Data/final_medicare.csv\")",
"_____no_output_____"
],
[
"def val_appended(card_outcomes): #MI, stroke, death\n for outcomes in card_outcomes:\n if (outcomes == 1):\n return 1\n return 0\nout_comp_cardiovascular_R1 = [] \nfor index in range(medicare.shape[0]):\n rel_outcomes = [medicare.at[index,'Out_IscheStroke_R1'], medicare.at[index,'Out_HemoStroke_R1'], medicare.at[index, 'Out_UncertainStroke_R1'], medicare.at[index, 'Out_MI_R1'], medicare.at[index,'ehr_death']]\n out_comp_cardiovascular_R1.append(val_appended(rel_outcomes))\n\nmedicare.insert(loc = 1, column = \"Out_comp_cardiovascular_R1\", value = out_comp_cardiovascular_R1)",
"_____no_output_____"
],
[
"from datetime import date\nimport math\nehr_claims_death = []\nfor rows in medicare[['D_Index', 'D_Death_C']].itertuples():\n d0 = date(int(rows[1][0:4]), int(rows[1][5:7]), int(rows[1][8:10]))\n try: \n math.isnan(float(rows[2]))\n ehr_claims_death.append(0)\n continue\n except ValueError:\n d1 = date(int(rows[2][0:4]), int(rows[2][5:7]), int(rows[2][8:10]))\n delta = d1 - d0\n print(delta.days)\n if (delta.days <= 365):\n ehr_claims_death.append(1)\n continue\n else:\n ehr_claims_death.append(0)\nmedicare['claims_death'] = ehr_claims_death \n ",
"1111\n147\n1835\n98\n1693\n1530\n11\n1531\n116\n43\n1966\n1931\n1772\n1744\n378\n460\n509\n1827\n595\n125\n27\n218\n369\n813\n598\n1608\n807\n800\n161\n40\n770\n1061\n340\n2070\n77\n177\n1072\n1045\n833\n142\n35\n616\n1092\n1220\n661\n658\n271\n1270\n588\n461\n116\n1069\n1276\n398\n718\n2279\n325\n1154\n144\n211\n841\n1145\n331\n28\n4\n51\n528\n72\n208\n314\n1008\n1704\n1582\n38\n1794\n1189\n1963\n1900\n1682\n825\n1248\n269\n271\n49\n960\n253\n18\n1397\n1736\n812\n233\n1465\n356\n168\n544\n55\n1904\n2091\n384\n2092\n189\n1357\n1721\n348\n194\n1301\n1413\n749\n459\n1591\n170\n180\n588\n2899\n746\n1743\n1411\n592\n390\n807\n737\n3398\n195\n2010\n339\n891\n468\n2149\n658\n2071\n51\n2626\n3004\n2987\n757\n212\n1576\n725\n1320\n3555\n1429\n1759\n1860\n1061\n1449\n751\n318\n1119\n3054\n2408\n2733\n64\n151\n532\n1205\n1533\n480\n127\n79\n2179\n1081\n792\n2699\n975\n3045\n1265\n2992\n1316\n1768\n1616\n1929\n2190\n2473\n174\n2848\n1118\n778\n148\n1112\n129\n2969\n2618\n576\n2494\n385\n351\n810\n1039\n1940\n587\n1565\n2061\n3348\n497\n1314\n1374\n1629\n2723\n2065\n308\n935\n1254\n252\n417\n1479\n460\n654\n2853\n2664\n11\n1557\n7\n560\n1128\n3274\n275\n1902\n483\n2229\n1939\n1859\n2909\n2641\n2632\n2091\n475\n1646\n56\n689\n663\n1244\n2932\n576\n1458\n137\n724\n2274\n2621\n5\n1283\n1530\n878\n1719\n421\n1604\n362\n6\n69\n547\n2080\n538\n1499\n71\n876\n2606\n906\n436\n922\n40\n1402\n1756\n2978\n2969\n61\n445\n146\n541\n3565\n372\n3476\n372\n654\n1023\n186\n533\n1296\n834\n1390\n1579\n1\n1786\n2032\n373\n3232\n232\n343\n190\n2731\n1\n235\n36\n267\n2087\n1556\n427\n183\n59\n2142\n1399\n1777\n671\n1400\n43\n2487\n2465\n444\n2463\n1409\n2037\n1398\n1466\n3138\n63\n243\n1054\n717\n3190\n1217\n334\n142\n1574\n227\n24\n1417\n2699\n665\n2760\n3595\n451\n278\n406\n977\n2739\n304\n86\n503\n1493\n2505\n1453\n338\n94\n1262\n1855\n584\n215\n753\n2578\n394\n2537\n266\n1017\n2495\n352\n3406\n76\n739\n175\n1355\n1796\n2106\n1293\n1173\n162\n2207\n600\n43\n1758\n568\n660\n2310\n268\n613\n2447\n2882\n893\n576\n912\n447\n2444\n1027\n1694\n908\n1534\n267\n618\n2108\n317\n1966\n2190\n1328\n3194\n987\n2956\n491\n18\n3262\n1271\n1694\n2524\n628\n506\n229\n974\n374\n351\n1560\n2072\n1148\n3430\n3209\n728\n329\n1510\n774\n76\n1759\n1181\n1097\n42\n56\n85\n1269\n706\n1005\n529\n2156\n1412\n835\n1140\n323\n2447\n544\n1037\n848\n1688\n68\n1032\n2666\n1321\n105\n1919\n175\n794\n1431\n1279\n2568\n2346\n966\n267\n1232\n1047\n2972\n37\n1538\n279\n2215\n3546\n416\n627\n3184\n3558\n2196\n689\n1202\n1031\n221\n1577\n2227\n1328\n1392\n1799\n334\n284\n2365\n2441\n2777\n1015\n82\n1826\n615\n1510\n2618\n2073\n1297\n32\n752\n598\n176\n1641\n1274\n1558\n2961\n1693\n3065\n67\n3326\n361\n407\n503\n2120\n1913\n58\n3512\n1595\n2623\n620\n1547\n2588\n897\n2750\n733\n1492\n969\n3579\n1270\n335\n5\n1772\n556\n910\n1021\n2395\n978\n2909\n988\n789\n802\n2717\n3296\n2744\n872\n227\n1908\n2631\n1533\n97\n1556\n3300\n894\n909\n2106\n2505\n1006\n2058\n1001\n1658\n138\n275\n1512\n592\n2386\n96\n521\n1466\n449\n2262\n317\n1271\n1835\n3127\n603\n689\n1307\n1341\n2168\n141\n1574\n102\n274\n221\n577\n2121\n150\n141\n47\n1707\n109\n438\n3237\n1811\n38\n2086\n184\n3\n57\n115\n1407\n2954\n412\n2955\n1766\n2098\n82\n129\n2545\n2091\n2187\n2417\n252\n3185\n375\n2936\n2109\n3169\n1473\n1248\n896\n1729\n123\n2590\n2160\n1054\n2721\n1360\n867\n1422\n1054\n166\n1619\n3335\n54\n2255\n1415\n1391\n1547\n1400\n2015\n1890\n1773\n3547\n1088\n1932\n1485\n722\n1310\n631\n27\n362\n1242\n1327\n3225\n94\n2526\n1650\n253\n3004\n5\n2403\n2907\n3062\n928\n2230\n3215\n2360\n1809\n705\n1007\n121\n368\n807\n507\n246\n1147\n883\n806\n689\n1147\n495\n496\n2297\n1250\n2119\n1657\n1927\n1148\n985\n160\n777\n1630\n2053\n2531\n273\n696\n2236\n99\n507\n366\n3644\n2092\n2081\n3463\n2259\n1626\n2728\n788\n745\n4\n961\n2330\n2629\n299\n2437\n1296\n493\n2362\n2739\n1037\n1373\n435\n310\n2990\n1282\n890\n1436\n2938\n2979\n792\n953\n3247\n1214\n3348\n248\n2321\n1056\n28\n1025\n80\n43\n2038\n280\n770\n1207\n650\n83\n1423\n2761\n1116\n1985\n1187\n2828\n754\n1164\n95\n1175\n1871\n1012\n1440\n272\n761\n1741\n2339\n180\n128\n1175\n1518\n52\n1160\n770\n1188\n227\n424\n201\n1144\n3125\n317\n1982\n2510\n539\n308\n727\n389\n750\n572\n3641\n399\n404\n1067\n10\n1194\n795\n457\n536\n1829\n2903\n2621\n944\n1142\n2330\n2653\n88\n1499\n3458\n3518\n2035\n1731\n1258\n2781\n1639\n41\n3379\n6\n928\n2271\n484\n453\n2124\n1570\n1101\n56\n2117\n1781\n1755\n3477\n387\n3162\n1163\n861\n117\n2630\n75\n2406\n1663\n665\n2940\n3282\n794\n2669\n1575\n550\n1119\n1340\n1071\n2365\n2762\n2189\n1074\n1006\n1661\n1113\n857\n79\n2288\n2917\n2954\n511\n2632\n2497\n1054\n2470\n1196\n519\n72\n937\n435\n507\n1286\n39\n613\n669\n402\n776\n1203\n607\n1360\n315\n453\n1999\n1604\n1136\n2324\n268\n1261\n963\n554\n388\n548\n1144\n766\n240\n862\n775\n71\n1617\n79\n400\n189\n652\n1695\n1109\n850\n1035\n1254\n792\n3455\n2251\n1769\n79\n808\n2048\n1438\n1037\n2130\n1653\n489\n1468\n1474\n1670\n5\n2995\n79\n32\n970\n1495\n1701\n2055\n1340\n486\n3076\n3381\n625\n1897\n639\n1304\n1694\n1470\n226\n896\n2719\n2692\n660\n3\n328\n1736\n2585\n2988\n943\n14\n1744\n1284\n67\n1428\n265\n748\n551\n49\n1979\n444\n3577\n1286\n1273\n240\n2960\n1321\n1491\n1432\n2533\n1427\n1626\n3445\n847\n119\n2358\n844\n2094\n2928\n588\n2713\n1274\n2998\n2699\n2317\n2659\n1025\n2527\n1728\n194\n368\n104\n767\n999\n3516\n2022\n1861\n54\n519\n1502\n892\n2499\n2701\n289\n954\n15\n1773\n61\n1455\n2788\n1447\n430\n2110\n1460\n1461\n289\n2979\n672\n2177\n2612\n805\n2285\n328\n562\n1625\n880\n2806\n2213\n1771\n2466\n2353\n86\n1399\n1810\n6\n571\n26\n800\n815\n428\n1745\n29\n1781\n2129\n2698\n2181\n744\n126\n1973\n887\n511\n1767\n3234\n530\n1744\n431\n2762\n1658\n711\n1731\n1900\n366\n954\n732\n2163\n1443\n84\n3454\n228\n1315\n1978\n1724\n458\n370\n3314\n2336\n1596\n4\n2185\n2816\n3217\n85\n3109\n830\n1632\n2242\n1904\n2524\n1560\n2581\n2347\n556\n10\n1219\n3408\n281\n1672\n2501\n2820\n1550\n1544\n2304\n417\n1834\n894\n491\n637\n2612\n372\n921\n903\n1584\n1462\n2699\n1446\n592\n2535\n788\n1645\n1695\n85\n2549\n510\n1065\n1323\n2082\n1077\n2047\n617\n859\n1416\n169\n3034\n3005\n353\n181\n156\n1748\n1248\n982\n753\n53\n1553\n54\n2024\n114\n1\n729\n131\n1880\n1821\n900\n58\n944\n2478\n1836\n123\n189\n102\n690\n1712\n2598\n100\n1111\n208\n3201\n1917\n30\n479\n2293\n1607\n3050\n447\n2393\n1360\n2978\n1212\n2749\n875\n2470\n1518\n1326\n199\n532\n2361\n2204\n2673\n457\n264\n1556\n773\n1408\n3006\n2208\n1385\n1026\n455\n510\n361\n1845\n842\n663\n411\n648\n489\n2\n1798\n3304\n660\n3258\n2859\n1115\n746\n641\n315\n1975\n1290\n2164\n870\n1848\n540\n1955\n1083\n580\n597\n1729\n2858\n428\n215\n84\n601\n539\n1586\n1246\n1060\n582\n1547\n401\n1654\n1032\n32\n13\n415\n1796\n429\n323\n706\n1887\n146\n2377\n17\n848\n142\n3506\n2051\n797\n63\n2796\n1169\n1845\n1121\n1801\n3175\n1024\n1164\n1722\n604\n3204\n2759\n744\n1397\n2533\n2851\n1968\n1053\n494\n2816\n434\n1561\n726\n679\n2738\n1099\n275\n388\n226\n581\n47\n502\n172\n3626\n1043\n1956\n1188\n2385\n356\n1807\n21\n5\n48\n173\n372\n849\n57\n2499\n2915\n2605\n48\n604\n1244\n1532\n695\n903\n1950\n155\n245\n230\n1097\n2666\n2166\n2158\n2334\n1125\n1156\n60\n999\n1150\n1192\n336\n332\n5\n602\n1879\n106\n75\n1100\n249\n1464\n1130\n755\n2425\n1451\n360\n3570\n717\n2005\n2399\n774\n279\n2209\n803\n3066\n2345\n1619\n3513\n403\n329\n962\n2831\n3536\n56\n1402\n436\n2577\n749\n47\n597\n504\n373\n2003\n6\n2382\n2897\n200\n52\n212\n588\n16\n1912\n523\n418\n117\n264\n535\n2418\n2500\n1257\n187\n93\n1995\n534\n1194\n970\n2420\n729\n751\n3295\n2398\n1911\n668\n4\n469\n2539\n2323\n3584\n282\n2658\n476\n423\n377\n35\n265\n1979\n1224\n368\n558\n1714\n1993\n62\n2541\n1\n2213\n3068\n920\n14\n33\n1324\n1988\n2863\n1420\n6\n492\n16\n1219\n420\n815\n494\n189\n3107\n35\n549\n238\n681\n1059\n1554\n1457\n731\n2242\n1982\n13\n115\n226\n2090\n2046\n317\n188\n682\n1182\n67\n1730\n122\n2197\n2944\n207\n2007\n467\n170\n778\n2284\n3607\n13\n1\n321\n302\n1013\n14\n1692\n3410\n467\n862\n1179\n348\n2\n238\n55\n1873\n3522\n44\n2484\n1024\n185\n240\n3529\n411\n409\n1991\n82\n2593\n1682\n24\n520\n1448\n334\n707\n1287\n2615\n61\n2658\n321\n2350\n2952\n1413\n921\n611\n984\n1287\n3204\n2530\n3561\n667\n1\n247\n3075\n2535\n1514\n1381\n3267\n368\n1122\n3314\n771\n2596\n1125\n155\n1932\n1190\n534\n1619\n2580\n1167\n1170\n3288\n1877\n1670\n381\n121\n3537\n3594\n1482\n757\n1691\n193\n95\n2718\n976\n151\n776\n1964\n2975\n1096\n508\n343\n804\n2524\n1328\n793\n3264\n2657\n2614\n2168\n1599\n4\n3379\n3430\n2905\n523\n172\n938\n49\n2401\n2250\n35\n52\n2514\n298\n3\n3253\n1476\n567\n154\n1052\n2000\n13\n155\n2477\n1928\n2314\n1839\n28\n44\n1622\n1603\n1664\n2602\n155\n851\n2709\n199\n2737\n1689\n602\n1097\n1155\n2135\n4\n4\n1443\n2413\n571\n2902\n187\n3606\n3627\n227\n2672\n1031\n858\n2636\n2715\n1776\n620\n955\n1931\n1195\n480\n2489\n1094\n2006\n14\n18\n44\n1157\n152\n1663\n725\n552\n336\n73\n894\n287\n2357\n128\n6\n526\n3385\n1902\n3396\n1706\n226\n163\n731\n1309\n915\n6\n686\n1683\n1422\n688\n535\n1497\n225\n1749\n3056\n2205\n150\n2488\n688\n2606\n2550\n1880\n1990\n1371\n830\n1854\n146\n2467\n329\n3522\n932\n617\n1943\n2938\n383\n2819\n1102\n466\n1103\n325\n408\n186\n478\n1735\n417\n284\n1008\n6\n3409\n2710\n1\n14\n117\n5\n940\n776\n1\n375\n658\n2594\n136\n3093\n508\n1558\n2256\n1328\n73\n2080\n547\n1426\n3224\n2225\n709\n22\n1024\n245\n2896\n2355\n566\n1436\n1999\n76\n63\n7\n1375\n569\n180\n376\n3245\n1970\n2389\n18\n3600\n661\n1848\n2786\n3308\n3152\n2232\n2735\n57\n109\n2402\n779\n572\n2365\n374\n2447\n2542\n147\n1659\n2701\n333\n2429\n812\n376\n3594\n2847\n10\n1864\n1105\n2791\n1791\n503\n375\n3520\n2703\n1136\n1558\n2399\n2637\n44\n1152\n77\n3506\n812\n3\n908\n1258\n334\n3287\n3538\n2218\n1323\n1120\n326\n1576\n254\n2326\n1464\n23\n1282\n2297\n686\n839\n3147\n153\n1187\n127\n2481\n1041\n508\n752\n1357\n2262\n1613\n2615\n981\n3206\n1709\n2381\n1071\n2536\n2871\n404\n282\n568\n2310\n609\n263\n200\n188\n37\n1039\n893\n1136\n1111\n1641\n22\n2988\n158\n863\n2935\n421\n1469\n656\n375\n2725\n32\n1121\n1419\n1213\n124\n2403\n1497\n29\n398\n2945\n341\n235\n895\n1479\n606\n438\n932\n2328\n390\n1382\n1598\n1078\n15\n1517\n1338\n24\n600\n2733\n1481\n1887\n2083\n2426\n306\n2171\n818\n70\n1221\n1674\n1172\n1675\n192\n916\n364\n2686\n1525\n3399\n1689\n110\n1405\n1623\n1565\n1193\n638\n279\n3128\n83\n709\n978\n563\n14\n1464\n458\n604\n32\n600\n2398\n1225\n160\n3438\n1653\n1965\n92\n144\n1125\n1700\n510\n1746\n1063\n2347\n110\n567\n2228\n2940\n1276\n1813\n499\n142\n61\n746\n609\n827\n3008\n1962\n375\n342\n3154\n1116\n1169\n14\n48\n599\n649\n1195\n1504\n12\n589\n301\n75\n1906\n3193\n75\n950\n2337\n14\n2469\n3415\n2503\n173\n418\n1800\n1476\n240\n770\n702\n296\n39\n969\n2367\n1989\n1703\n146\n2640\n522\n1717\n69\n3307\n1031\n1545\n1136\n169\n1767\n1338\n272\n868\n546\n2523\n310\n1855\n1822\n2840\n165\n1034\n2465\n229\n2205\n2181\n1838\n3169\n3528\n23\n280\n2046\n2295\n107\n281\n1560\n81\n1097\n126\n1153\n3303\n1072\n176\n192\n2307\n43\n1761\n3064\n321\n1062\n51\n2855\n2228\n410\n482\n1245\n2306\n397\n1364\n393\n3090\n519\n2214\n790\n969\n2570\n1757\n1207\n360\n846\n215\n144\n718\n87\n1281\n3314\n664\n1329\n890\n2\n372\n1483\n1297\n3322\n1366\n2588\n228\n313\n10\n355\n1401\n388\n774\n3\n160\n3024\n1798\n116\n713\n1961\n2314\n740\n1764\n1613\n1782\n1903\n1211\n29\n1764\n1987\n1049\n2215\n869\n377\n1571\n2689\n779\n17\n535\n44\n333\n1613\n756\n1669\n42\n2759\n2342\n3147\n2671\n471\n1448\n1448\n3092\n346\n1094\n191\n268\n1954\n3602\n943\n553\n1404\n655\n827\n735\n73\n562\n2094\n134\n158\n147\n910\n441\n12\n310\n952\n2864\n4\n1034\n144\n62\n303\n893\n1180\n28\n185\n484\n7\n613\n94\n3\n2748\n9\n756\n871\n1\n2584\n3595\n808\n95\n1045\n349\n271\n2970\n1071\n1191\n33\n171\n3605\n3322\n3628\n2364\n1415\n688\n3557\n15\n1343\n2273\n2968\n1629\n1019\n1368\n278\n2264\n1882\n227\n2210\n717\n2612\n2694\n2998\n805\n965\n233\n1360\n1305\n1366\n917\n1333\n2563\n1998\n3290\n1306\n565\n1836\n3161\n3349\n2087\n2678\n648\n752\n185\n186\n1302\n21\n836\n477\n404\n972\n304\n329\n136\n2646\n3000\n918\n227\n1000\n1770\n1296\n2044\n3233\n917\n897\n2661\n350\n1851\n525\n377\n290\n732\n1212\n2176\n1469\n1971\n1313\n1445\n564\n343\n2226\n1817\n663\n1556\n556\n1442\n1576\n1269\n186\n16\n1367\n203\n523\n456\n677\n409\n382\n369\n681\n2639\n3578\n282\n1531\n419\n803\n1172\n2886\n2129\n419\n2608\n2660\n981\n1101\n1109\n1024\n90\n7\n2049\n3106\n1985\n422\n2554\n323\n1400\n549\n2797\n301\n256\n7\n677\n1916\n526\n714\n1477\n554\n376\n909\n1048\n1890\n30\n3585\n1363\n3298\n742\n1092\n596\n243\n1142\n2003\n2426\n192\n791\n1366\n773\n1153\n2030\n1842\n1441\n65\n104\n2460\n1765\n744\n1\n1508\n1811\n3000\n3097\n1563\n900\n2729\n32\n280\n841\n39\n3378\n669\n1919\n282\n713\n640\n252\n1282\n1778\n1340\n1159\n667\n43\n1945\n3478\n868\n7\n553\n227\n2737\n41\n953\n2064\n174\n1403\n663\n1838\n259\n229\n1491\n830\n11\n203\n191\n621\n18\n2507\n842\n162\n189\n431\n2636\n652\n2097\n869\n1326\n1461\n2099\n2747\n1211\n741\n1909\n941\n278\n369\n1111\n646\n247\n1113\n768\n653\n1590\n365\n359\n1258\n462\n1772\n2924\n2993\n2\n2105\n677\n485\n2981\n1\n10\n1328\n2439\n2316\n1460\n714\n9\n252\n28\n3234\n2244\n1964\n1\n98\n204\n1873\n3226\n1497\n1910\n142\n645\n2721\n3517\n2657\n185\n3203\n1120\n11\n201\n337\n42\n1234\n1731\n1591\n888\n327\n130\n3042\n542\n95\n78\n482\n115\n5\n1788\n2580\n2287\n108\n1157\n3052\n28\n2077\n33\n740\n1910\n26\n204\n2409\n2240\n237\n964\n45\n3443\n2\n417\n2050\n852\n306\n3296\n3238\n1694\n1492\n125\n2203\n566\n939\n1329\n178\n2241\n614\n3133\n794\n2704\n551\n1633\n2197\n182\n2987\n78\n482\n1477\n83\n2515\n214\n1064\n1755\n2138\n662\n2327\n15\n1925\n874\n2859\n2\n441\n1040\n1272\n701\n1875\n337\n3349\n81\n2823\n3094\n3083\n557\n2245\n943\n11\n45\n705\n5\n1270\n1172\n13\n514\n888\n1840\n1826\n1133\n2436\n215\n3043\n1225\n399\n1739\n1466\n867\n2292\n790\n2859\n13\n5\n2073\n2736\n3593\n2169\n278\n583\n1749\n773\n417\n188\n1408\n373\n1510\n23\n2392\n1846\n17\n3351\n357\n1341\n318\n159\n2517\n366\n519\n214\n1024\n3344\n716\n"
],
[
"count = 0\nt_val = 0\nfor values in ehr_claims_death: \n t_val = t_val + 1\n if (values == 1): \n count = count + 1\nprint(count, t_val)",
"5003 52277\n"
],
[
"ehr_claims_death = []\nfor rows in medicare[['ehr_death', 'claims_death']].itertuples():\n ehr_claims_death.append(rows[1] or rows[2])\ncount = 0\nmedicare['ehr_claims_death'] = ehr_claims_death \n\n ",
"_____no_output_____"
],
[
"def val_appended(card_outcomes): #MI, stroke, death\n for outcomes in card_outcomes:\n if (outcomes == 1):\n return 1\n return 0\nout_comp_cardiovascular_RC1 = [] \nfor index in range(medicare.shape[0]):\n rel_outcomes = [medicare.at[index,'Out_IscheStroke_RC1'], medicare.at[index,'Out_HemoStroke_RC1'], medicare.at[index, 'Out_UncertainStroke_RC1'], medicare.at[index, 'Out_MI_RC1'], medicare.at[index,'ehr_claims_death']]\n out_comp_cardiovascular_RC1.append(val_appended(rel_outcomes))\n\nmedicare.insert(loc = 1, column = \"Out_comp_RC1\", value = out_comp_cardiovascular_RC1)",
"_____no_output_____"
],
[
"medicare['Out_comp_RC1']",
"_____no_output_____"
],
[
"count = 0\nfor values in medicare['Out_comp_RC1']:\n if (values == 1):\n count = count + 1\nprint(count)",
"6672\n"
],
[
"medicare.to_csv(\"/netapp2/home/Data/final2_medicare.csv\")",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ece827e170096a5b2d4d3e2f73e20deab76e333d | 28,970 | ipynb | Jupyter Notebook | idb_tf/explore_index.ipynb | iDigBio/idb-spark | abaedf871beae749c42cc737675db1b9b14d7d57 | [
"MIT"
] | 1 | 2019-03-11T08:17:46.000Z | 2019-03-11T08:17:46.000Z | idb_tf/explore_index.ipynb | iDigBio/idb-spark | abaedf871beae749c42cc737675db1b9b14d7d57 | [
"MIT"
] | null | null | null | idb_tf/explore_index.ipynb | iDigBio/idb-spark | abaedf871beae749c42cc737675db1b9b14d7d57 | [
"MIT"
] | null | null | null | 75.639687 | 17,224 | 0.78174 | [
[
[
"import pyspark.sql.functions as sql\nimport pyspark.sql.types as types\nidb_df_version = \"20161119\"\nsize=\"\"",
"_____no_output_____"
],
[
"idb_tf_df = sqlContext.read.parquet(\"/guoda/data/idigbio-{0}-tf{1}.parquet\".format(idb_df_version, size))\nidb_tf_df.count()",
"_____no_output_____"
],
[
"idb_df = sqlContext.read.parquet(\"/guoda/data/idigbio-{0}{1}.parquet\".format(idb_df_version, size))\nidb_df.count()",
"_____no_output_____"
],
[
"idb_df_ids = (idb_df\n .select(idb_df[\"uuid\"].alias(\"idb_uuid\"),\n idb_df[\"catalognumber\"].alias(\"idb_catalognumber\"))\n )",
"_____no_output_____"
],
[
"idb_df_notes = (idb_df\n .select(idb_df[\"uuid\"].alias(\"note_uuid\"),\n sql.concat_ws(\" \", idb_df[\"data.dwc:occurrenceRemarks\"],\n idb_df[\"data.dwc:eventRemarks\"],\n idb_df[\"data.dwc:fieldNotes\"]\n )\n .alias(\"note\")\n )\n )",
"_____no_output_____"
],
[
"joined = (idb_df_ids \n .join(idb_tf_df, on=idb_df_ids[\"idb_catalognumber\"]==idb_tf_df[\"token\"])\n .join(idb_df_notes, on=sql.column(\"uuid\")==idb_df_notes[\"note_uuid\"])\n .withColumn(\"catalognumber_len\", sql.length(sql.column(\"idb_catalognumber\")))\n )\n\njoined.count()",
"_____no_output_____"
],
[
"joined.head()",
"_____no_output_____"
],
[
"length_pd = (joined\n .groupBy(joined[\"catalognumber_len\"])\n .count()\n ).toPandas()\nlength_pd.head(2)",
"_____no_output_____"
],
[
"length_pd.shape",
"_____no_output_____"
],
[
"import numpy\nlength_pd[\"log_count\"] = numpy.log10(length_pd[\"count\"])",
"_____no_output_____"
],
[
"print(length_pd)",
" catalognumber_len count log_catalognumber_len log_count\n0 1 1314912287 0.000000 9.118897\n1 6 138556200 0.778151 8.141626\n2 16 2 1.204120 0.301030\n3 3 212986935 0.477121 8.328353\n4 5 123868957 0.698970 8.092962\n5 9 45511 0.954243 4.658116\n6 4 531911093 0.602060 8.725839\n7 8 35533 0.903090 4.550632\n8 7 73042 0.845098 4.863573\n9 10 4 1.000000 0.602060\n10 11 7017 1.041393 3.846151\n11 14 5 1.146128 0.698970\n12 2 613337855 0.301030 8.787700\n"
],
[
"import matplotlib\nimport matplotlib.pyplot as plt\nmatplotlib.style.use('ggplot')\n\nplt.figure();\n(length_pd\n .sort_values(by=\"catalognumber_len\")\n .plot(x=\"catalognumber_len\", y=\"log_count\", kind=\"bar\")\n)\n\nplt.show()",
"_____no_output_____"
],
[
"joined.filter(joined[\"catalognumber_len\"]==11).head(10)",
"_____no_output_____"
],
[
"(joined\n .write\n .parquet(\"/outputs/idb-tokens-joined-{}.parquet\".format(idb_df_version))\n)",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ece828553549f21c29ef1b27e15634fc938c7dba | 10,670 | ipynb | Jupyter Notebook | 2-Natural Language Processing with Probabilistic Models/week-2/Parts-of-Speech Tagging.ipynb | rahulverma7788/coursera-natural-language-processing-specialization-2-3650 | 687df12f6da6e8fc1c72a4c72e2d8fbd5b4fbe4b | [
"Apache-2.0"
] | null | null | null | 2-Natural Language Processing with Probabilistic Models/week-2/Parts-of-Speech Tagging.ipynb | rahulverma7788/coursera-natural-language-processing-specialization-2-3650 | 687df12f6da6e8fc1c72a4c72e2d8fbd5b4fbe4b | [
"Apache-2.0"
] | null | null | null | 2-Natural Language Processing with Probabilistic Models/week-2/Parts-of-Speech Tagging.ipynb | rahulverma7788/coursera-natural-language-processing-specialization-2-3650 | 687df12f6da6e8fc1c72a4c72e2d8fbd5b4fbe4b | [
"Apache-2.0"
] | null | null | null | 39.962547 | 379 | 0.709372 | [
[
[
"empty"
]
]
] | [
"empty"
] | [
[
"empty"
]
] |
ece841dc8fdd903514973d5c9126e83fe24c0bb1 | 7,818 | ipynb | Jupyter Notebook | PredictWaterSplit/Regression package.ipynb | xqzh/Perovskite | 5d66c67953f1c6571f1f3c3b89d6571619587e31 | [
"MIT"
] | 1 | 2021-08-23T09:09:45.000Z | 2021-08-23T09:09:45.000Z | PredictWaterSplit/Regression package.ipynb | xqzh/Perovskite | 5d66c67953f1c6571f1f3c3b89d6571619587e31 | [
"MIT"
] | null | null | null | PredictWaterSplit/Regression package.ipynb | xqzh/Perovskite | 5d66c67953f1c6571f1f3c3b89d6571619587e31 | [
"MIT"
] | 6 | 2018-02-13T23:36:05.000Z | 2021-03-24T04:15:18.000Z | 23.477477 | 161 | 0.574572 | [
[
[
"import pandas as pd",
"_____no_output_____"
],
[
"from KRRcode import open_database",
"_____no_output_____"
],
[
"from KRRcode import predictbyKRR",
"_____no_output_____"
],
[
"from KRRcode import outlier",
"_____no_output_____"
],
[
"from KRRcode import featureselect",
"_____no_output_____"
]
],
[
[
"## This notebook is to show how we make prediction with kernel ridge regression and analyze the outliers",
"_____no_output_____"
]
],
[
[
"perovskite,values,data_total = open_database.read_database()",
"_____no_output_____"
],
[
"traindata,testdata = predictbyKRR.build_data(data_total)",
"_____no_output_____"
],
[
"feature_list = ['anion_X', 'anion_IE', 'A_X', 'A_IE', 'A_aff', 'B_IE', 'B_aff', 'volume', 'mass', 'A_R', 'B_R', 'aff_A+B', 'aff_A-B', 'A_R_max', 'B_R_max']",
"_____no_output_____"
]
],
[
[
"### Predict the band energy and heat of formation",
"_____no_output_____"
]
],
[
[
"CB_dir_predict_train,CB_dir_predict_test = predictbyKRR.predict_Band(feature_list,traindata,testdata,'CB_dir')",
"_____no_output_____"
],
[
"predictbyKRR.plot_predict(CB_dir_predict_test,testdata.CB_dir,\n CB_dir_predict_train,traindata.CB_dir,\n 'prediction of direct conduction band')",
"_____no_output_____"
],
[
"CB_ind_predict_train,CB_ind_predict_test = predictbyKRR.predict_Band(feature_list,traindata,testdata,'CB_ind')",
"_____no_output_____"
],
[
"type(CB_ind_predict_train)",
"_____no_output_____"
],
[
"predictbyKRR.plot_predict(CB_ind_predict_test,testdata.CB_ind,\n CB_ind_predict_train,traindata.CB_ind,\n 'prediction of indirect conduction band')",
"_____no_output_____"
],
[
"VB_dir_predict_train,VB_dir_predict_test = predictbyKRR.predict_Band(feature_list,traindata,testdata,'VB_dir')",
"_____no_output_____"
],
[
"predictbyKRR.plot_predict(VB_dir_predict_test,testdata.VB_dir,\n VB_dir_predict_train,traindata.VB_dir,\n 'prediction of direct valence band')",
"_____no_output_____"
],
[
"VB_ind_predict_train,VB_ind_predict_test = predictbyKRR.predict_Band(feature_list,traindata,testdata,'VB_ind')",
"_____no_output_____"
],
[
"predictbyKRR.plot_predict(VB_ind_predict_test,testdata.VB_ind,\n VB_ind_predict_train,traindata.VB_ind,\n 'prediction of indirect valence band')",
"_____no_output_____"
],
[
"hf_predict_train,hf_predict_test = predictbyKRR.predict_Band(feature_list,traindata,testdata,'heat_of_formation')",
"_____no_output_____"
],
[
"predictbyKRR.plot_predict(hf_predict_test,testdata.heat_of_formation,\n hf_predict_train,traindata.heat_of_formation,\n 'prediction of heat of formation')",
"_____no_output_____"
]
],
[
[
"### find the recurring outliers in testdata and plot them",
"_____no_output_____"
]
],
[
[
"pred_compare = testdata.copy()\npred_compare['CB_ind_pred'] = CB_ind_predict_test\npred_compare['VB_ind_pred'] = VB_ind_predict_test\npred_compare['CB_dir_pred'] = CB_dir_predict_test\npred_compare['VB_dir_pred'] = VB_dir_predict_test\npred_compare['hf_pred'] = hf_predict_test\n\npred_compare['ind_gap'] = pred_compare['CB_ind_pred']-pred_compare['VB_ind_pred']\npred_compare['dir_gap'] = pred_compare['CB_dir_pred']-pred_compare['VB_dir_pred']\n",
"_____no_output_____"
],
[
"recuroutlier_test = outlier.collectoutlier(pred_compare)",
"_____no_output_____"
],
[
"recuroutlier_train.groupby('anion').count()",
"_____no_output_____"
],
[
"recuroutlier_test.groupby('anion').count()",
"_____no_output_____"
],
[
"outlier.plot_outlier(CB_dir_predict_test,testdata.CB_dir,\n recuroutlier_test.CB_dir_pred,recuroutlier_test.CB_dir,\n 'Prediction of Direct Conduction Band')",
"_____no_output_____"
],
[
"outlier.plot_outlier(VB_dir_predict_test,testdata.VB_dir,\n recuroutlier_test.VB_dir_pred,recuroutlier_test.VB_dir,\n 'Prediction of Direct Valence Band')",
"_____no_output_____"
],
[
"outlier.plot_outlier(VB_ind_predict_test,testdata.VB_ind,\n recuroutlier_test.VB_ind_pred,recuroutlier_test.VB_ind,\n 'Prediction of Indirect Valence Band')",
"_____no_output_____"
],
[
"outlier.plot_outlier(CB_ind_predict_test,testdata.CB_ind,\n recuroutlier_test.CB_ind_pred,recuroutlier_test.CB_ind,\n 'Prediction of Indirect Valence Band')",
"_____no_output_____"
]
]
] | [
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ece8515ee6d79d67e50d441ba62c1a3462520dae | 13,025 | ipynb | Jupyter Notebook | ProblemSets/PS1-julia-intro/gps_01.ipynb | gpetrini/OU_Econometrics_III | 81b5f35999d6b10f65f84b3344593d1c28acf1e2 | [
"MIT"
] | null | null | null | ProblemSets/PS1-julia-intro/gps_01.ipynb | gpetrini/OU_Econometrics_III | 81b5f35999d6b10f65f84b3344593d1c28acf1e2 | [
"MIT"
] | null | null | null | ProblemSets/PS1-julia-intro/gps_01.ipynb | gpetrini/OU_Econometrics_III | 81b5f35999d6b10f65f84b3344593d1c28acf1e2 | [
"MIT"
] | null | null | null | 28.689427 | 373 | 0.509175 | [
[
[
"empty"
]
]
] | [
"empty"
] | [
[
"empty"
]
] |
ece85fa8b90d4b1f5fcdc0d01162488118a4782c | 421,538 | ipynb | Jupyter Notebook | nbs/001_utils.ipynb | duchaba/tsai | 694c26c22fa102b236fe4763111095c40ec8d7b3 | [
"Apache-2.0"
] | null | null | null | nbs/001_utils.ipynb | duchaba/tsai | 694c26c22fa102b236fe4763111095c40ec8d7b3 | [
"Apache-2.0"
] | null | null | null | nbs/001_utils.ipynb | duchaba/tsai | 694c26c22fa102b236fe4763111095c40ec8d7b3 | [
"Apache-2.0"
] | null | null | null | 96.638698 | 76,552 | 0.817639 | [
[
[
"# default_exp utils",
"_____no_output_____"
]
],
[
[
"# Utilities\n\n> Helper functions used throughout the library not related to timeseries data.",
"_____no_output_____"
]
],
[
[
"#export\nimport string\nfrom scipy.stats import ttest_ind, ks_2samp, pearsonr, spearmanr, normaltest, linregress\nfrom tsai.imports import *",
"_____no_output_____"
],
[
"# ensure these folders exist for testing purposes\nfns = ['data', 'export', 'models']\nfor fn in fns: \n path = Path('.')/fn\n if not os.path.exists(path): os.makedirs(path)",
"_____no_output_____"
],
[
"#export\ndef totensor(o):\n if isinstance(o, torch.Tensor): return o\n elif isinstance(o, np.ndarray): return torch.from_numpy(o)\n elif isinstance(o, pd.DataFrame): return torch.from_numpy(o.values)\n else: \n try: return torch.tensor(o)\n except: warn(f\"Can't convert {type(o)} to torch.Tensor\", Warning)\n\n\ndef toarray(o):\n if isinstance(o, np.ndarray): return o\n elif isinstance(o, torch.Tensor): return o.cpu().numpy()\n elif isinstance(o, pd.DataFrame): return o.values\n else:\n try: return np.asarray(o)\n except: warn(f\"Can't convert {type(o)} to np.array\", Warning)\n \n \ndef toL(o):\n if isinstance(o, L): return o\n elif isinstance(o, (np.ndarray, torch.Tensor)): return L(o.tolist())\n else:\n try: return L(o)\n except: warn(f'passed object needs to be of type L, list, np.ndarray or torch.Tensor but is {type(o)}', Warning)\n\n\ndef to3dtensor(o):\n o = totensor(o)\n if o.ndim == 3: return o\n elif o.ndim == 1: return o[None, None]\n elif o.ndim == 2: return o[:, None]\n assert False, f'Please, review input dimensions {o.ndim}'\n\n\ndef to2dtensor(o):\n o = totensor(o)\n if o.ndim == 2: return o\n elif o.ndim == 1: return o[None]\n elif o.ndim == 3: return o[0]\n assert False, f'Please, review input dimensions {o.ndim}'\n\n\ndef to1dtensor(o):\n o = totensor(o)\n if o.ndim == 1: return o\n elif o.ndim == 3: return o[0,0]\n if o.ndim == 2: return o[0]\n assert False, f'Please, review input dimensions {o.ndim}'\n\n\ndef to3darray(o):\n o = toarray(o)\n if o.ndim == 3: return o\n elif o.ndim == 1: return o[None, None]\n elif o.ndim == 2: return o[:, None]\n assert False, f'Please, review input dimensions {o.ndim}'\n\n\ndef to2darray(o):\n o = toarray(o)\n if o.ndim == 2: return o\n elif o.ndim == 1: return o[None]\n elif o.ndim == 3: return o[0]\n assert False, f'Please, review input dimensions {o.ndim}'\n\n\ndef to1darray(o):\n o = toarray(o)\n if o.ndim == 1: return o\n elif o.ndim == 3: o = o[0,0]\n elif o.ndim == 2: o = o[0]\n assert False, f'Please, review input dimensions {o.ndim}'\n \n \ndef to3d(o):\n if o.ndim == 3: return o\n if isinstance(o, (np.ndarray, pd.DataFrame)): return to3darray(o)\n if isinstance(o, torch.Tensor): return to3dtensor(o)\n \n \ndef to2d(o):\n if o.ndim == 2: return o\n if isinstance(o, np.ndarray): return to2darray(o)\n if isinstance(o, torch.Tensor): return to2dtensor(o)\n \n \ndef to1d(o):\n if o.ndim == 1: return o\n if isinstance(o, np.ndarray): return to1darray(o)\n if isinstance(o, torch.Tensor): return to1dtensor(o)\n \n \ndef to2dPlus(o):\n if o.ndim >= 2: return o\n if isinstance(o, np.ndarray): return to2darray(o)\n elif isinstance(o, torch.Tensor): return to2dtensor(o)\n \n \ndef to3dPlus(o):\n if o.ndim >= 3: return o\n if isinstance(o, np.ndarray): return to3darray(o)\n elif isinstance(o, torch.Tensor): return to3dtensor(o)\n \n \ndef to2dPlusTensor(o):\n return to2dPlus(totensor(o))\n\n\ndef to2dPlusArray(o):\n return to2dPlus(toarray(o))\n\n\ndef to3dPlusTensor(o):\n return to3dPlus(totensor(o))\n\n\ndef to3dPlusArray(o):\n return to3dPlus(toarray(o))\n\n\ndef todtype(dtype):\n def _to_type(o, dtype=dtype):\n if o.dtype == dtype: return o\n elif isinstance(o, torch.Tensor): o = o.to(dtype=dtype)\n elif isinstance(o, np.ndarray): o = o.astype(dtype)\n return o\n return _to_type",
"_____no_output_____"
],
[
"a = np.random.rand(100).astype(np.float32)\nb = torch.from_numpy(a).float()\ntest_eq(totensor(a), b)\ntest_eq(a, toarray(b))\ntest_eq(to3dtensor(a).ndim, 3)\ntest_eq(to2dtensor(a).ndim, 2)\ntest_eq(to1dtensor(a).ndim, 1)\ntest_eq(to3darray(b).ndim, 3)\ntest_eq(to2darray(b).ndim, 2)\ntest_eq(to1darray(b).ndim, 1)",
"_____no_output_____"
],
[
"data = np.random.rand(10, 20)\ndf = pd.DataFrame(data)\ndf['target'] = np.random.randint(0, 3, len(df))\nX = df[df.columns[:-1]]\ny = df['target']\ntest_eq(to3darray(X).shape, (10, 1, 20))\ntest_eq(toarray(y).shape, (10,))",
"_____no_output_____"
],
[
"#export\ndef bytes2size(\n size_bytes : int, # Number of bytes \n decimals=2 # Number of decimals in the output\n )->str:\n if size_bytes == 0: return \"0B\"\n size_name = (\"B\", \"KB\", \"MB\", \"GB\", \"TB\", \"PB\", \"EB\", \"ZB\", \"YB\")\n i = int(math.floor(math.log(size_bytes, 1024)))\n p = math.pow(1024, i)\n s = round(size_bytes / p, decimals)\n return f'{s} {size_name[i]}'\n\ndef bytes2GB(byts):\n return round(byts / math.pow(1024, 3), 2)\n\ndef get_size(\n o, # Any object \n return_str : bool = True, # True returns size in human-readable format (KB, MB, GB, ...). False in bytes.\n decimals : int = 2, # Number of decimals in the output\n ):\n s = sys.getsizeof(o)\n if return_str: return bytes2size(s, decimals=decimals)\n else: return s\n\ndef get_dir_size(\n dir_path : str, # path to directory \n return_str : bool = True, # True returns size in human-readable format (KB, MB, GB, ...). False in bytes.\n decimals : int = 2, # Number of decimals in the output\n verbose : bool = False, # Controls verbosity\n ):\n assert os.path.isdir(dir_path)\n total_size = 0\n for dirpath, dirnames, filenames in os.walk(dir_path):\n for f in filenames:\n fp = os.path.join(dirpath, f)\n # skip if it is symbolic link\n if not os.path.islink(fp):\n fp_size = os.path.getsize(fp)\n total_size += fp_size\n pv(f'file: {fp[-50:]:50} size: {fp_size}', verbose)\n if return_str: \n return bytes2size(total_size, decimals=decimals)\n return total_size\n\ndef get_file_size(\n file_path : str, # path to file \n return_str : bool = True, # True returns size in human-readable format (KB, MB, GB, ...). False in bytes.\n decimals : int = 2, # Number of decimals in the output\n ):\n assert os.path.isfile(file_path)\n fsize = os.path.getsize(file_path)\n if return_str: \n return bytes2size(fsize, decimals=decimals)\n return fsize",
"_____no_output_____"
],
[
"a = np.random.rand(10, 5, 3)\ntest_eq(get_size(a, True), '1.3 KB')",
"_____no_output_____"
],
[
"#export\ndef is_file(path):\n return os.path.isfile(path)\n\ndef is_dir(path):\n return os.path.isdir(path)",
"_____no_output_____"
],
[
"test_eq(is_file(\"001_utils.ipynb\"), True)\ntest_eq(is_file(\"utils.ipynb\"), False)",
"_____no_output_____"
],
[
"#export\ndef delete_all_in_dir(tgt_dir, exception=None):\n import shutil\n if exception is not None and len(L(exception)) > 1: exception = tuple(exception)\n for file in os.listdir(tgt_dir):\n if exception is not None and file.endswith(exception): continue\n file_path = os.path.join(tgt_dir, file)\n if os.path.isfile(file_path) or os.path.islink(file_path): os.unlink(file_path)\n elif os.path.isdir(file_path): shutil.rmtree(file_path)",
"_____no_output_____"
],
[
"#export\ndef reverse_dict(dictionary): \n return {v: k for k, v in dictionary.items()}",
"_____no_output_____"
],
[
"#export\ndef is_tuple(o): return isinstance(o, tuple)",
"_____no_output_____"
],
[
"#export\ndef itemify(*o, tup_id=None): \n o = [o_ for o_ in L(*o) if o_ is not None]\n items = L(o).zip()\n if tup_id is not None: return L([item[tup_id] for item in items])\n else: return items",
"_____no_output_____"
],
[
"a = [1, 2, 3]\nb = [4, 5, 6]\nprint(itemify(a, b))\ntest_eq(len(itemify(a, b)), len(a))\na = [1, 2, 3]\nb = None\nprint(itemify(a, b))\ntest_eq(len(itemify(a, b)), len(a))\na = [1, 2, 3]\nb = [4, 5, 6]\nc = None\nprint(itemify(a, b, c))\ntest_eq(len(itemify(a, b, c)), len(a))",
"[(1, 4), (2, 5), (3, 6)]\n[(1,), (2,), (3,)]\n[(1, 4), (2, 5), (3, 6)]\n"
],
[
"#export\ndef isnone(o):\n return o is None\n\ndef exists(o): return o is not None\n\ndef ifelse(a, b, c):\n \"`b` if `a` is True else `c`\"\n return b if a else c",
"_____no_output_____"
],
[
"a = np.array(3)\ntest_eq(isnone(a), False)\ntest_eq(exists(a), True)\nb = None\ntest_eq(isnone(b), True)\ntest_eq(exists(b), False)",
"_____no_output_____"
],
[
"#export\ndef is_not_close(a, b, eps=1e-5):\n \"Is `a` within `eps` of `b`\"\n if hasattr(a, '__array__') or hasattr(b, '__array__'):\n return (abs(a - b) > eps).all()\n if isinstance(a, (Iterable, Generator)) or isinstance(b, (Iterable, Generator)):\n return is_not_close(np.array(a), np.array(b), eps=eps)\n return abs(a - b) > eps\n\n\ndef test_not_close(a, b, eps=1e-5):\n \"`test` that `a` is within `eps` of `b`\"\n test(a, b, partial(is_not_close, eps=eps), 'not_close')\n\n\ndef test_type(a, b):\n return test_eq(type(a), type(b))\n\n\ndef test_ok(f, *args, **kwargs):\n try: \n f(*args, **kwargs)\n e = 0\n except: \n e = 1\n pass\n test_eq(e, 0)\n \ndef test_not_ok(f, *args, **kwargs):\n try: \n f(*args, **kwargs)\n e = 0\n except: \n e = 1\n pass\n test_eq(e, 1)\n \ndef test_error(error, f, *args, **kwargs):\n try: f(*args, **kwargs)\n except Exception as e: \n test_eq(str(e), error)\n \ndef test_eq_nan(a,b):\n \"`test` that `a==b` excluding nan values (valid for torch.Tensor and np.ndarray)\"\n mask_a = torch.isnan(a) if isinstance(a, torch.Tensor) else np.isnan(a)\n mask_b = torch.isnan(b) if isinstance(b, torch.Tensor) else np.isnan(b)\n test(a[~mask_a],b[~mask_b],equals, '==')",
"_____no_output_____"
],
[
"#export\ndef assert_fn(*args, **kwargs): assert False, 'assertion test'\ntest_error('assertion test', assert_fn, 35, a=3)",
"_____no_output_____"
],
[
"#export\ndef test_gt(a,b):\n \"`test` that `a>b`\"\n test(a,b,gt,'>')\n\ndef test_ge(a,b):\n \"`test` that `a>=b`\"\n test(a,b,ge,'>')\n \ndef test_lt(a,b):\n \"`test` that `a>b`\"\n test(a,b,lt,'<')\n\ndef test_le(a,b):\n \"`test` that `a>b`\"\n test(a,b,le,'<=')",
"_____no_output_____"
],
[
"test_ok(test_gt, 5, 4)\ntest_not_ok(test_gt, 4, 4)\ntest_ok(test_ge, 4, 4)\ntest_not_ok(test_ge, 3, 4)\n\ntest_ok(test_lt, 3, 4)\ntest_not_ok(test_lt, 4, 4)\ntest_ok(test_le, 4, 4)\ntest_not_ok(test_le, 5, 4)",
"_____no_output_____"
],
[
"t = torch.rand(100)\nt[t<.5] = np.nan\ntest_ne(t, t)\ntest_eq_nan(t, t)",
"_____no_output_____"
],
[
"#export\ndef stack(o, axis=0, retain=True):\n if hasattr(o, '__array__'): return o\n if isinstance(o[0], torch.Tensor):\n return retain_type(torch.stack(tuple(o), dim=axis), o[0]) if retain else torch.stack(tuple(o), dim=axis)\n else:\n return retain_type(np.stack(o, axis), o[0]) if retain else np.stack(o, axis)\n \n \ndef stack_pad(o, padding_value=np.nan):\n 'Converts a an iterable into a numpy array using padding if necessary'\n if not is_listy(o) or not is_array(o):\n if not hasattr(o, \"ndim\"): o = np.asarray([o])\n else: o = np.asarray(o)\n o_ndim = 1\n if o.ndim > 1:\n o_ndim = o.ndim\n o_shape = o.shape\n o = o.flatten()\n o = [oi if (is_array(oi) and oi.ndim > 0) or is_listy(oi) else [oi] for oi in o]\n row_length = len(max(o, key=len))\n result = np.full((len(o), row_length), padding_value)\n for i,row in enumerate(o):\n result[i, :len(row)] = row\n if o_ndim > 1:\n if row_length == 1:\n result = result.reshape(*o_shape)\n else:\n result = result.reshape(*o_shape, row_length)\n return result",
"_____no_output_____"
],
[
"o = [[0,1,2], [4,5,6,7]]\ntest_eq(stack_pad(o).shape, (1, 2, 4))\ntest_eq(type(stack_pad(o)), np.ndarray)\ntest_eq(np.isnan(stack_pad(o)).sum(), 1)",
"/Users/nacho/opt/anaconda3/envs/py37torch110/lib/python3.7/site-packages/ipykernel_launcher.py:13: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray.\n del sys.path[0]\n"
],
[
"o = 3\nprint(stack_pad(o))\ntest_eq(stack_pad(o), np.array([[3.]]))\no = [4,5]\nprint(stack_pad(o))\ntest_eq(stack_pad(o), np.array([[4., 5.]]))\no = [[0,1,2], [4,5,6,7]]\nprint(stack_pad(o))\no = np.array([0, [1,2]], dtype=object)\nprint(stack_pad(o))\no = np.array([[[0], [10, 20], [100, 200, 300]], [[0, 1, 2, 3], [10, 20], [100]]], dtype=object)\nprint(stack_pad(o))\no = np.array([0, [10, 20]], dtype=object)\nprint(stack_pad(o))",
"[[3.]]\n[[4. 5.]]\n[[[ 0. 1. 2. nan]\n [ 4. 5. 6. 7.]]]\n[[ 0. nan]\n [ 1. 2.]]\n[[[ 0. nan nan nan]\n [ 10. 20. nan nan]\n [100. 200. 300. nan]]\n\n [[ 0. 1. 2. 3.]\n [ 10. 20. nan nan]\n [100. nan nan nan]]]\n[[ 0. nan]\n [10. 20.]]\n"
],
[
"a = np.random.rand(2, 3, 4)\nt = torch.from_numpy(a)\ntest_eq_type(stack(itemify(a, tup_id=0)), a)\ntest_eq_type(stack(itemify(t, tup_id=0)), t)",
"_____no_output_____"
],
[
"#export\ndef pad_sequences(\n o, # Iterable object\n maxlen:int=None, # Optional max length of the output. If None, max length of the longest individual sequence.\n dtype:(str, type)=np.float64, # Type of the output sequences. To pad sequences with variable length strings, you can use object.\n padding:str='pre', # 'pre' or 'post' pad either before or after each sequence.\n truncating:str='pre', # 'pre' or 'post' remove values from sequences larger than maxlen, either at the beginning or at the end of the sequences.\n padding_value:float=np.nan, # Value used for padding.\n):\n \"Transforms an iterable with sequences into a 3d numpy array using padding or truncating sequences if necessary\"\n \n assert padding in ['pre', 'post']\n assert truncating in ['pre', 'post']\n assert is_iter(o)\n\n if not is_array(o):\n o = [to2darray(oi) for oi in o]\n seq_len = maxlen or max(o, key=len).shape[-1]\n result = np.full((len(o), o[0].shape[-2], seq_len), padding_value, dtype=dtype)\n for i,values in enumerate(o):\n if truncating == 'pre':\n values = values[..., -seq_len:]\n else:\n values = values[..., :seq_len]\n if padding == 'pre':\n result[i, :, -values.shape[-1]:] = values\n else:\n result[i, :, :values.shape[-1]] = values \n return result",
"_____no_output_____"
]
],
[
[
"This function transforms a list (of length n_samples) of sequences into a 3d numpy array of shape:\n\n```bash\n [n_samples x n_vars x seq_len]\n```\n\nseq_len is either the maxlen argument if provided, or the length of the longest sequence in the list.\n\nSequences that are shorter than seq_len are padded with value until they are seq_len long.\n\nSequences longer than seq_len are truncated so that they fit the desired length.\n\nThe position where padding or truncation happens is determined by the arguments padding and truncating, respectively. Pre-padding or removing values from the beginning of the sequence is the default.\n\nInput sequences to pad_sequences may be have 1, 2 or 3 dimensions:",
"_____no_output_____"
]
],
[
[
"# 1 dim\na1 = np.arange(6)\na2 = np.arange(3) * 10\na3 = np.arange(2) * 100\no = [a1, a2, a3]\npadded_o = pad_sequences(o, maxlen=4, dtype=np.float64, padding='post', truncating='pre', padding_value=np.nan)\ntest_eq(padded_o.shape, (3, 1, 4))\npadded_o",
"_____no_output_____"
],
[
"# 2 dim\na1 = np.arange(12).reshape(2, 6)\na2 = np.arange(6).reshape(2, 3) * 10\na3 = np.arange(4).reshape(2, 2) * 100\no = [a1, a2, a3]\npadded_o = pad_sequences(o, maxlen=4, dtype=np.float64, padding='post', truncating='pre', padding_value=np.nan)\ntest_eq(padded_o.shape, (3, 2, 4))\npadded_o",
"_____no_output_____"
],
[
"# 3 dim\na1 = np.arange(10).reshape(1, 2, 5)\na2 = np.arange(6).reshape(1, 2, 3) * 10\na3 = np.arange(4).reshape(1, 2, 2) * 100\no = [a1, a2, a3]\npadded_o = pad_sequences(o, maxlen=None, dtype=np.float64, padding='pre', truncating='pre', padding_value=np.nan)\ntest_eq(padded_o.shape, (3, 2, 5))\npadded_o",
"_____no_output_____"
],
[
"# 3 dim\na1 = np.arange(10).reshape(1, 2, 5)\na2 = np.arange(6).reshape(1, 2, 3) * 10\na3 = np.arange(4).reshape(1, 2, 2) * 100\no = [a1, a2, a3]\npadded_o = pad_sequences(o, maxlen=4, dtype=np.float64, padding='pre', truncating='pre', padding_value=np.nan)\ntest_eq(padded_o.shape, (3, 2, 4))\npadded_o",
"_____no_output_____"
],
[
"# 3 dim\na1 = np.arange(10).reshape(1, 2, 5)\na2 = np.arange(6).reshape(1, 2, 3) * 10\na3 = np.arange(4).reshape(1, 2, 2) * 100\no = [a1, a2, a3]\npadded_o = pad_sequences(o, maxlen=4, dtype=np.float64, padding='post', truncating='pre', padding_value=np.nan)\ntest_eq(padded_o.shape, (3, 2, 4))\npadded_o",
"_____no_output_____"
],
[
"# 3 dim\na1 = np.arange(10).reshape(1, 2, 5)\na2 = np.arange(6).reshape(1, 2, 3) * 10\na3 = np.arange(4).reshape(1, 2, 2) * 100\no = [a1, a2, a3]\npadded_o = pad_sequences(o, maxlen=4, dtype=np.float64, padding='post', truncating='post', padding_value=np.nan)\ntest_eq(padded_o.shape, (3, 2, 4))\npadded_o",
"_____no_output_____"
],
[
"# iterable is a list of lists\na1 = np.arange(12).reshape(1, 2, 6).tolist()\na2 = (np.arange(6).reshape(1, 2, 3) * 10).tolist()\na3 = (np.arange(4).reshape(1, 2, 2) * 100).tolist()\no = [a1, a2, a3]\npadded_o = pad_sequences(o, maxlen=None, dtype=np.float64, padding='post', truncating='pre', padding_value=np.nan)\ntest_eq(padded_o.shape, (3, 2, 6))\npadded_o",
"_____no_output_____"
],
[
"#export\ndef match_seq_len(*arrays):\n max_len = stack([x.shape[-1] for x in arrays]).max()\n return [np.pad(x, pad_width=((0,0), (0,0), (max_len - x.shape[-1], 0)), mode='constant', constant_values=0) for x in arrays]",
"_____no_output_____"
],
[
"a = np.random.rand(10, 5, 8)\nb = np.random.rand(3, 5, 10)\nc, d = match_seq_len(a, b)\ntest_eq(c.shape[-1], d.shape[-1])",
"_____no_output_____"
],
[
"#export\ndef random_shuffle(o, random_state=None):\n import sklearn\n res = sklearn.utils.shuffle(o, random_state=random_state)\n if isinstance(o, L): return L(list(res))\n return res",
"_____no_output_____"
],
[
"a = np.arange(10)\ntest_eq_type(random_shuffle(a, 1), np.array([2, 9, 6, 4, 0, 3, 1, 7, 8, 5]))\nt = torch.arange(10)\ntest_eq_type(random_shuffle(t, 1), tensor([2, 9, 6, 4, 0, 3, 1, 7, 8, 5]))\nl = list(a)\ntest_eq(random_shuffle(l, 1), [2, 9, 6, 4, 0, 3, 1, 7, 8, 5])\nl2 = L(l)\ntest_eq_type(random_shuffle(l2, 1), L([2, 9, 6, 4, 0, 3, 1, 7, 8, 5]))",
"_____no_output_____"
],
[
"#export\ndef cat2int(o):\n from fastai.data.transforms import Categorize\n from fastai.data.core import TfmdLists\n cat = Categorize()\n cat.setup(o)\n return stack(TfmdLists(o, cat)[:])",
"_____no_output_____"
],
[
"a = np.array(['b', 'a', 'a', 'b', 'a', 'b', 'a'])\ntest_eq_type(cat2int(a), TensorCategory([1, 0, 0, 1, 0, 1, 0]))",
"_____no_output_____"
],
[
"TensorBase([1,2,3])",
"_____no_output_____"
],
[
"#export\ndef cycle_dl(dl, show_progress_bar=False):\n if show_progress_bar: \n for _ in progress_bar(dl): _\n else: \n for _ in dl: _\n \ndef cycle_dl_to_device(dl, show_progress_bar=False):\n if show_progress_bar: \n for bs in progress_bar(dl): [b.to(default_device()) for b in bs]\n else:\n for bs in dl: [b.to(default_device()) for b in bs]\n \ndef cycle_dl_estimate(dl, iters=10):\n iters = min(iters, len(dl))\n iterator = iter(dl)\n timer.start(False)\n for _ in range(iters): next(iterator)\n t = timer.stop()\n return (t/iters * len(dl)).total_seconds()",
"_____no_output_____"
],
[
"#export\ndef cache_data(o, slice_len=10_000, verbose=False):\n start = 0\n n_loops = (len(o) - 1) // slice_len + 1\n pv(f'{n_loops} loops', verbose)\n timer.start(False)\n for i in range(n_loops):\n o[slice(start,start + slice_len)] \n if verbose and (i+1) % 10 == 0: print(f'{i+1:4} elapsed time: {timer.elapsed()}')\n start += slice_len\n pv(f'{i+1:4} total time : {timer.stop()}\\n', verbose)\n \nmemmap2cache = cache_data\ncache_memmap = cache_data",
"_____no_output_____"
],
[
"#export\ndef get_func_defaults(f): \n import inspect\n fa = inspect.getfullargspec(f)\n if fa.defaults is None: return dict(zip(fa.args, [''] * (len(fa.args))))\n else: return dict(zip(fa.args, [''] * (len(fa.args) - len(fa.defaults)) + list(fa.defaults)))",
"_____no_output_____"
],
[
"#export\ndef get_idx_from_df_col_vals(df, col, val_list):\n return [df[df[col] == val].index[0] for val in val_list]",
"_____no_output_____"
],
[
"#export\ndef get_sublist_idxs(aList, bList):\n \"Get idxs that when applied to aList will return bList. aList must contain all values in bList\"\n sorted_aList = aList[np.argsort(aList)]\n return np.argsort(aList)[np.searchsorted(sorted_aList, bList)]",
"_____no_output_____"
],
[
"x = np.array([3, 5, 7, 1, 9, 8, 6, 2])\ny = np.array([6, 1, 5, 7])\nidx = get_sublist_idxs(x, y)\ntest_eq(x[idx], y)\nx = np.array([3, 5, 7, 1, 9, 8, 6, 6, 2])\ny = np.array([6, 1, 5, 7, 5])\nidx = get_sublist_idxs(x, y)\ntest_eq(x[idx], y)",
"_____no_output_____"
],
[
"#export\ndef flatten_list(l):\n return [item for sublist in l for item in sublist]",
"_____no_output_____"
],
[
"#export\ndef display_pd_df(df, max_rows:Union[bool, int]=False, max_columns:Union[bool, int]=False):\n if max_rows:\n old_max_rows = pd.get_option('display.max_rows')\n if max_rows is not True and isinstance(max_rows, Integral): pd.set_option('display.max_rows', max_rows)\n else: pd.set_option('display.max_rows', df.shape[0])\n if max_columns:\n old_max_columns = pd.get_option('display.max_columns')\n if max_columns is not True and isinstance(max_columns, Integral): pd.set_option('display.max_columns', max_columns)\n else: pd.set_option('display.max_columns', df.shape[1])\n display(df)\n if max_rows: pd.set_option('display.max_rows', old_max_rows)\n if max_columns: pd.set_option('display.max_columns', old_max_columns)",
"_____no_output_____"
],
[
"old_max_rows, old_max_columns = pd.get_option('display.max_rows'), pd.get_option('display.max_columns')\ndf = pd.DataFrame(np.random.rand(70, 25))\ndisplay_pd_df(df, max_rows=2, max_columns=3)\ntest_eq(old_max_rows, pd.get_option('display.max_rows'))\ntest_eq(old_max_columns, pd.get_option('display.max_columns'))",
"_____no_output_____"
],
[
"#export\ndef ttest(data1, data2, equal_var=False):\n \"Calculates t-statistic and p-value based on 2 sample distributions\"\n t_stat, p_value = ttest_ind(data1, data2, equal_var=equal_var)\n return t_stat, np.sign(t_stat) * p_value\n\ndef kstest(data1, data2, alternative='two-sided', mode='auto', by_axis=None):\n \"\"\"Performs the two-sample Kolmogorov-Smirnov test for goodness of fit.\n \n Parameters\n data1, data2: Two arrays of sample observations assumed to be drawn from a continuous distributions. Sample sizes can be different.\n alternative: {‘two-sided’, ‘less’, ‘greater’}, optional. Defines the null and alternative hypotheses. Default is ‘two-sided’. \n mode: {‘auto’, ‘exact’, ‘asymp’}, optional. Defines the method used for calculating the p-value. \n by_axis (optional, int): for arrays with more than 1 dimension, the test will be run for each variable in that axis if by_axis is not None.\n \"\"\"\n if by_axis is None:\n stat, p_value = ks_2samp(data1.flatten(), data2.flatten(), alternative=alternative, mode=mode)\n return stat, np.sign(stat) * p_value\n else:\n assert data1.shape[by_axis] == data2.shape[by_axis], f\"both arrays must have the same size along axis {by_axis}\"\n stats, p_values = [], []\n for i in range(data1.shape[by_axis]):\n d1 = np.take(data1, indices=i, axis=by_axis)\n d2 = np.take(data2, indices=i, axis=by_axis)\n stat, p_value = ks_2samp(d1.flatten(), d2.flatten(), alternative=alternative, mode=mode)\n stats.append(stat) \n p_values.append(np.sign(stat) * p_value)\n return stats, p_values \n \n\ndef tscore(o): \n if o.std() == 0: return 0\n else: return np.sqrt(len(o)) * o.mean() / o.std()",
"_____no_output_____"
],
[
"a = np.random.normal(0.5, 1, 100)\nb = np.random.normal(0.15, .5, 50)\nplt.hist(a, 50)\nplt.hist(b, 50)\nplt.show()\nttest(a,b)",
"_____no_output_____"
],
[
"a = np.random.normal(0.5, 1, (100,3))\nb = np.random.normal(0.5, 1, (50,))\nkstest(a,b)",
"_____no_output_____"
],
[
"a = np.random.normal(0.5, 1, (100,3))\nb = np.random.normal(0.15, .5, (50,))\nkstest(a,b)",
"_____no_output_____"
],
[
"data1 = np.random.normal(0,1,(100, 5, 3))\ndata2 = np.random.normal(0,2,(100, 5, 3))\nkstest(data1, data2, by_axis=1)",
"_____no_output_____"
],
[
"a = np.random.normal(0.5, 1, 100)\nt = torch.normal(0.5, 1, (100, ))\ntscore(a), tscore(t)",
"_____no_output_____"
],
[
"#export\ndef ttest_tensor(a, b):\n \"differentiable pytorch function equivalent to scipy.stats.ttest_ind with equal_var=False\"\n # calculate standard errors\n se1, se2 = torch.std(a)/np.sqrt(len(a)), torch.std(b)/np.sqrt(len(b))\n # standard error on the difference between the samples\n sed = torch.sqrt(se1**2.0 + se2**2.0)\n # calculate the t statistic\n t_stat = (torch.mean(a) - torch.mean(b)) / sed\n return t_stat",
"_____no_output_____"
],
[
"a = torch.rand(100).requires_grad_(True) + .1\nb = torch.rand(100).requires_grad_(True)\nttest_tensor(a, b)",
"_____no_output_____"
],
[
"#export\ndef pcc(a, b):\n return pearsonr(a, b)[0]\n\ndef scc(a, b):\n return spearmanr(a, b)[0]\n\na = np.random.normal(0.5, 1, 100)\nb = np.random.normal(0.15, .5, 100)\npcc(a, b), scc(a, b)",
"_____no_output_____"
],
[
"#export\ndef remove_fn(fn, verbose=False):\n \"Removes a file (fn) if exists\"\n try: \n os.remove(fn)\n pv(f'{fn} file removed', verbose)\n except OSError: \n pv(f'{fn} does not exist', verbose)\n pass",
"_____no_output_____"
],
[
"#export\ndef npsave(array_fn, array, verbose=True):\n remove_fn(array_fn, verbose)\n pv(f'saving {array_fn}...', verbose)\n np.save(array_fn, array)\n pv(f'...{array_fn} saved', verbose)\n \nnp_save = npsave",
"_____no_output_____"
],
[
"fn = 'data/remove_fn_test.npy'\na = np.zeros(1)\nnpsave(fn, a)\ndel a\nnp.load(fn, mmap_mode='r+')\nremove_fn(fn, True)\nremove_fn(fn, True)",
"data/remove_fn_test.npy does not exist\nsaving data/remove_fn_test.npy...\n...data/remove_fn_test.npy saved\ndata/remove_fn_test.npy file removed\ndata/remove_fn_test.npy does not exist\n"
],
[
"#export\ndef permute_2D(array, axis=None):\n \"Permute rows or columns in an array. This can be used, for example, in feature permutation\"\n if axis == 0: return array[np.random.randn(*array.shape).argsort(axis=0), np.arange(array.shape[-1])[None, :]] \n elif axis == 1 or axis == -1: return array[np.arange(len(array))[:,None], np.random.randn(*array.shape).argsort(axis=1)] \n return array[np.random.randn(*array.shape).argsort(axis=0), np.random.randn(*array.shape).argsort(axis=1)] ",
"_____no_output_____"
],
[
"s = np.arange(100 * 50).reshape(100, 50) \ntest_eq(permute_2D(s, axis=0).mean(0), s.mean(0))\ntest_ne(permute_2D(s, axis=0), s)\ntest_eq(permute_2D(s, axis=1).mean(1), s.mean(1))\ntest_ne(permute_2D(s, axis=1), s)\ntest_ne(permute_2D(s), s)",
"_____no_output_____"
],
[
"#export\ndef random_normal():\n \"Returns a number between -1 and 1 with a normal distribution\"\n while True:\n o = np.random.normal(loc=0., scale=1/3)\n if abs(o) <= 1: break\n return o\n\ndef random_half_normal():\n \"Returns a number between 0 and 1 with a half-normal distribution\"\n while True:\n o = abs(np.random.normal(loc=0., scale=1/3))\n if o <= 1: break\n return o\n\ndef random_normal_tensor(shape=1, device=None):\n \"Returns a tensor of a predefined shape between -1 and 1 with a normal distribution\"\n return torch.empty(shape, device=device).normal_(mean=0, std=1/3).clamp_(-1, 1)\n\ndef random_half_normal_tensor(shape=1, device=None):\n \"Returns a tensor of a predefined shape between 0 and 1 with a half-normal distribution\"\n return abs(torch.empty(shape, device=device).normal_(mean=0, std=1/3)).clamp_(0, 1)",
"_____no_output_____"
],
[
"#export\nfrom matplotlib.backends.backend_agg import FigureCanvasAgg\n\ndef default_dpi():\n DPI = plt.gcf().get_dpi()\n plt.close()\n return int(DPI)\n\ndef get_plot_fig(size=None, dpi=default_dpi()):\n fig = plt.figure(figsize=(size / dpi, size / dpi), dpi=dpi, frameon=False) if size else plt.figure()\n ax = fig.add_axes([0,0,1,1])\n ax.spines['top'].set_visible(False)\n ax.spines['right'].set_visible(False)\n ax.spines['bottom'].set_visible(False)\n ax.spines['left'].set_visible(False)\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n config = plt.gcf()\n plt.close('all')\n return config\n\ndef fig2buf(fig):\n canvas = FigureCanvasAgg(fig)\n fig.canvas.draw()\n return np.asarray(canvas.buffer_rgba())[..., :3]",
"_____no_output_____"
],
[
"default_dpi()",
"_____no_output_____"
],
[
"#export\ndef plot_scatter(x, y, deg=1):\n linreg = linregress(x, y)\n plt.scatter(x, y, label=f'R2:{linreg.rvalue:.2f}', color='lime', edgecolor='black', alpha=.5)\n plt.plot(np.unique(x), np.poly1d(np.polyfit(x, y, deg))(np.unique(x)), color='r')\n plt.legend(loc='best')\n plt.show()",
"_____no_output_____"
],
[
"a = np.random.rand(100)\nb = np.random.rand(100)**2\nplot_scatter(a, b)",
"_____no_output_____"
],
[
"#export\ndef get_idxs(o, aList): return array([o.tolist().index(v) for v in aList])",
"_____no_output_____"
],
[
"a = random_shuffle(np.arange(100, 200))\nb = np.random.choice(a, 10, False)\nidxs = get_idxs(a, b)\ntest_eq(a[idxs], b)",
"_____no_output_____"
],
[
"#export\ndef apply_cmap(o, cmap):\n o = toarray(o)\n out = plt.get_cmap(cmap)(o)[..., :3]\n out = tensor(out).squeeze(1)\n return out.permute(0, 3, 1, 2)",
"_____no_output_____"
],
[
"a = np.random.rand(16, 1, 40, 50)\ns = L(a.shape)\ns[1] = 3\ntest_eq(L(apply_cmap(a, 'viridis').shape), s)\n\ns[0] = 1\na = np.random.rand(1, 40, 50)\ntest_eq(L(apply_cmap(a, 'viridis').shape), s)",
"_____no_output_____"
],
[
"#export\ndef torch_tile(a, n_tile, dim=0):\n if ismin_torch(\"1.10\") and dim == 0:\n if isinstance(n_tile, tuple): \n return torch.tile(a, n_tile)\n return torch.tile(a, (n_tile,))\n init_dim = a.size(dim)\n repeat_idx = [1] * a.dim()\n repeat_idx[dim] = n_tile\n a = a.repeat(*(repeat_idx))\n order_index = torch.cat([init_dim * torch.arange(n_tile) + i for i in range(init_dim)]).to(device=a.device)\n return torch.index_select(a, dim, order_index)",
"_____no_output_____"
],
[
"test_eq(torch_tile(torch.arange(2), 3), tensor([0, 1, 0, 1, 0, 1]))",
"_____no_output_____"
],
[
"#export\ndef to_tsfresh_df(ts):\n r\"\"\"Prepares a time series (Tensor/ np.ndarray) to be used as a tsfresh dataset to allow feature extraction\"\"\"\n ts = to3d(ts)\n if isinstance(ts, np.ndarray):\n ids = np.repeat(np.arange(len(ts)), ts.shape[-1]).reshape(-1,1)\n joint_ts = ts.transpose(0,2,1).reshape(-1, ts.shape[1])\n cols = ['id'] + np.arange(ts.shape[1]).tolist()\n df = pd.DataFrame(np.concatenate([ids, joint_ts], axis=1), columns=cols)\n elif isinstance(ts, torch.Tensor):\n ids = torch_tile(torch.arange(len(ts)), ts.shape[-1]).reshape(-1,1)\n joint_ts = ts.transpose(1,2).reshape(-1, ts.shape[1])\n cols = ['id']+np.arange(ts.shape[1]).tolist()\n df = pd.DataFrame(torch.cat([ids, joint_ts], dim=1).numpy(), columns=cols)\n df['id'] = df['id'].astype(int)\n df.reset_index(drop=True, inplace=True)\n return df",
"_____no_output_____"
],
[
"ts = torch.rand(16, 3, 20)\na = to_tsfresh_df(ts)\nts = ts.numpy()\nb = to_tsfresh_df(ts)",
"_____no_output_____"
],
[
"#export\ndef pcorr(a, b): \n return pearsonr(a, b)\n\ndef scorr(a, b): \n corr = spearmanr(a, b)\n return corr[0], corr[1]",
"_____no_output_____"
],
[
"#export\ndef torch_diff(t, lag=1, pad=True, append=0):\n import torch.nn.functional as F\n diff = t[..., lag:] - t[..., :-lag]\n if pad: \n return F.pad(diff, (lag, append))\n else: \n return diff",
"_____no_output_____"
],
[
"t = torch.arange(24).reshape(2,3,4)\ntest_eq(torch_diff(t, 1)[..., 1:].float().mean(), 1.)\ntest_eq(torch_diff(t, 2)[..., 2:].float().mean(), 2.)",
"_____no_output_____"
],
[
"#export\ndef get_outliers_IQR(o, axis=None, quantile_range=(25.0, 75.0)):\n if isinstance(o, torch.Tensor):\n Q1 = torch.nanquantile(o, quantile_range[0]/100, axis=axis, keepdims=axis is not None)\n Q3 = torch.nanquantile(o, quantile_range[1]/100, axis=axis, keepdims=axis is not None)\n else:\n Q1 = np.nanpercentile(o, quantile_range[0], axis=axis, keepdims=axis is not None)\n Q3 = np.nanpercentile(o, quantile_range[1], axis=axis, keepdims=axis is not None)\n IQR = Q3 - Q1\n return Q1 - 1.5 * IQR, Q3 + 1.5 * IQR\n\ndef clip_outliers(o, axis=None):\n min_outliers, max_outliers = get_outliers_IQR(o, axis=axis)\n if isinstance(o, (np.ndarray, pd.core.series.Series)):\n return np.clip(o, min_outliers, max_outliers)\n elif isinstance(o, torch.Tensor):\n return torch.clamp(o, min_outliers, max_outliers)\n\ndef get_percentile(o, percentile, axis=None):\n if isinstance(o, torch.Tensor): \n return torch.nanquantile(o, percentile/100, axis=axis, keepdims=axis is not None)\n else: \n return np.nanpercentile(o, percentile, axis=axis, keepdims=axis is not None)\n\ndef torch_clamp(o, min=None, max=None):\n r\"\"\"Clamp torch.Tensor using 1 or multiple dimensions\"\"\"\n if min is not None: o = torch.max(o, min)\n if max is not None: o = torch.min(o, max)\n return o",
"_____no_output_____"
],
[
"t = torch.randn(2,3,100)\ntest_eq(type(get_outliers_IQR(t, -1)[0]), torch.Tensor)\na = t.numpy()\ntest_eq(type(get_outliers_IQR(a, -1)[0]), np.ndarray)\ntest_close(get_percentile(t, 25).numpy(), get_percentile(a, 25))",
"_____no_output_____"
],
[
"#export\ndef get_robustscale_params(o, by_var=True, percentiles=(25, 75), eps=1e-6):\n assert o.ndim == 3\n if by_var: \n median = np.nanpercentile(o, 50, axis=(0,2), keepdims=True)\n Q1 = np.nanpercentile(o, percentiles[0], axis=(0,2), keepdims=True)\n Q3 = np.nanpercentile(o, percentiles[1], axis=(0,2), keepdims=True)\n IQR = Q3 - Q1\n else:\n median = np.nanpercentile(o, .50)\n Q1 = np.nanpercentile(o, percentiles[0])\n Q3 = np.nanpercentile(o, percentiles[1])\n IQR = Q3 - Q1\n if eps is not None: IQR = np.maximum(IQR, eps)\n return median, IQR",
"_____no_output_____"
],
[
"a = np.random.rand(16, 3, 100)\na[a>.8] = np.nan\nmedian, IQR = get_robustscale_params(a, by_var=True, percentiles=(25, 75))\na_scaled = (a - median) / IQR\ntest_eq(a.shape, a_scaled.shape)\ntest_eq(np.isnan(median).sum(),0)\ntest_eq(np.isnan(IQR).sum(),0)\ntest_eq(np.isnan(a), np.isnan(a_scaled))",
"_____no_output_____"
],
[
"#export\ndef torch_slice_by_dim(t, index, dim=-1, **kwargs):\n if not isinstance(index, torch.Tensor): index = torch.Tensor(index)\n assert t.ndim == index.ndim, \"t and index must have the same ndim\"\n index = index.long()\n return torch.gather(t, dim, index, **kwargs)",
"_____no_output_____"
],
[
"t = torch.rand(5, 3)\nindex = torch.randint(0, 3, (5, 1))\n# index = [[0, 2], [0, 1], [1, 2], [0, 2], [0, 1]]\ntorch_slice_by_dim(t, index)",
"_____no_output_____"
],
[
"#export\ndef torch_nanmean(o, dim=None, keepdim=False):\n \"\"\"There's currently no torch.nanmean function\"\"\"\n mask = torch.isnan(o)\n if mask.any():\n output = torch.from_numpy(np.asarray(np.nanmean(o.cpu().numpy(), axis=dim, keepdims=keepdim))).to(o.device)\n if output.shape == mask.shape:\n output[mask] = 0\n return output\n else:\n return torch.mean(o, dim=dim, keepdim=keepdim) if dim is not None else torch.mean(o)\n\n\ndef torch_nanstd(o, dim=None, keepdim=False):\n \"\"\"There's currently no torch.nanstd function\"\"\"\n mask = torch.isnan(o)\n if mask.any():\n output = torch.from_numpy(np.asarray(np.nanstd(o.cpu().numpy(), axis=dim, keepdims=keepdim))).to(o.device)\n if output.shape == mask.shape:\n output[mask] = 1\n return output\n else:\n return torch.std(o, dim=dim, keepdim=keepdim) if dim is not None else torch.std(o)",
"_____no_output_____"
],
[
"t = torch.rand(1000)\nt[:100] = float('nan')\nassert torch_nanmean(t).item() > 0",
"_____no_output_____"
],
[
"#export\ndef concat(*ls, dim=0):\n \"Concatenate tensors, arrays, lists, or tuples by a dimension\"\n if not len(ls): return []\n it = ls[0]\n if isinstance(it, torch.Tensor): return torch.cat(ls, dim=dim)\n elif isinstance(it, np.ndarray): return np.concatenate(ls, axis=dim)\n else:\n res = np.concatenate(ls, axis=dim).tolist()\n return retain_type(res, typ=type(it))",
"_____no_output_____"
],
[
"#export\ndef reduce_memory_usage(df):\n \n start_memory = df.memory_usage().sum() / 1024**2\n print(f\"Memory usage of dataframe is {start_memory} MB\")\n \n for col in df.columns:\n col_type = df[col].dtype\n \n if col_type != 'object':\n c_min = df[col].min()\n c_max = df[col].max()\n \n if str(col_type)[:3] == 'int':\n if c_min > np.iinfo(np.int8).min and c_max < np.iinfo(np.int8).max:\n df[col] = df[col].astype(np.int8)\n elif c_min > np.iinfo(np.int16).min and c_max < np.iinfo(np.int16).max:\n df[col] = df[col].astype(np.int16)\n elif c_min > np.iinfo(np.int32).min and c_max < np.iinfo(np.int32).max:\n df[col] = df[col].astype(np.int32)\n elif c_min > np.iinfo(np.int64).min and c_max < np.iinfo(np.int64).max:\n df[col] = df[col].astype(np.int64)\n \n else:\n if c_min > np.finfo(np.float16).min and c_max < np.finfo(np.float16).max:\n df[col] = df[col].astype(np.float16)\n elif c_min > np.finfo(np.float32).min and c_max < np.finfo(np.float32).max:\n df[col] = df[col].astype(np.float32)\n else:\n pass\n else:\n df[col] = df[col].astype('category')\n \n end_memory = df.memory_usage().sum() / 1024**2\n print(f\"Memory usage of dataframe after reduction {end_memory} MB\")\n print(f\"Reduced by {100 * (start_memory - end_memory) / start_memory} % \")\n return df",
"_____no_output_____"
],
[
"#export\ndef cls_name(o): return o.__class__.__name__",
"_____no_output_____"
],
[
"test_eq(cls_name(timer), 'Timer')",
"_____no_output_____"
],
[
"#export\ndef roll2d(o, roll1: Union[None, list, int] = None, roll2: Union[None, list, int] = None):\n \"\"\"Rolls a 2D object on the indicated axis\n This solution is based on https://stackoverflow.com/questions/20360675/roll-rows-of-a-matrix-independently\n \"\"\"\n \n assert o.ndim == 2, \"roll2D can only be applied to 2d objects\"\n axis1, axis2 = np.ogrid[:o.shape[0], :o.shape[1]]\n if roll1 is not None:\n if isinstance(roll1, int): axis1 = axis1 - np.array(roll1).reshape(1,1)\n else: axis1 = np.array(roll1).reshape(o.shape[0],1)\n if roll2 is not None:\n if isinstance(roll2, int): axis2 = axis2 - np.array(roll2).reshape(1,1)\n else: axis2 = np.array(roll2).reshape(1,o.shape[1])\n return o[axis1, axis2]\n\n\ndef roll3d(o, roll1: Union[None, list, int] = None, roll2: Union[None, list, int] = None, roll3: Union[None, list, int] = None):\n \"\"\"Rolls a 3D object on the indicated axis\n This solution is based on https://stackoverflow.com/questions/20360675/roll-rows-of-a-matrix-independently\n \"\"\"\n \n assert o.ndim == 3, \"roll3D can only be applied to 3d objects\"\n axis1, axis2, axis3 = np.ogrid[:o.shape[0], :o.shape[1], :o.shape[2]]\n if roll1 is not None:\n if isinstance(roll1, int): axis1 = axis1 - np.array(roll1).reshape(1,1,1)\n else: axis1 = np.array(roll1).reshape(o.shape[0],1,1)\n if roll2 is not None:\n if isinstance(roll2, int): axis2 = axis2 - np.array(roll2).reshape(1,1,1)\n else: axis2 = np.array(roll2).reshape(1,o.shape[1],1)\n if roll3 is not None:\n if isinstance(roll3, int): axis3 = axis3 - np.array(roll3).reshape(1,1,1)\n else: axis3 = np.array(roll3).reshape(1,1,o.shape[2])\n return o[axis1, axis2, axis3]\n\n\ndef random_roll2d(o, axis=(), replace=False):\n \"\"\"Rolls a 2D object on the indicated axis\n This solution is based on https://stackoverflow.com/questions/20360675/roll-rows-of-a-matrix-independently\n \"\"\"\n \n assert o.ndim == 2, \"roll2D can only be applied to 2d objects\"\n axis1, axis2 = np.ogrid[:o.shape[0], :o.shape[1]]\n if 0 in axis:\n axis1 = np.random.choice(np.arange(o.shape[0]), o.shape[0], replace).reshape(-1, 1)\n if 1 in axis:\n axis2 = np.random.choice(np.arange(o.shape[1]), o.shape[1], replace).reshape(1, -1)\n return o[axis1, axis2]\n\n\ndef random_roll3d(o, axis=(), replace=False):\n \"\"\"Randomly rolls a 3D object along the indicated axes\n This solution is based on https://stackoverflow.com/questions/20360675/roll-rows-of-a-matrix-independently\n \"\"\"\n \n assert o.ndim == 3, \"random_roll3d can only be applied to 3d objects\"\n axis1, axis2, axis3 = np.ogrid[:o.shape[0], :o.shape[1], :o.shape[2]]\n if 0 in axis:\n axis1 = np.random.choice(np.arange(o.shape[0]), o.shape[0], replace).reshape(-1, 1, 1)\n if 1 in axis:\n axis2 = np.random.choice(np.arange(o.shape[1]), o.shape[1], replace).reshape(1, -1, 1)\n if 2 in axis:\n axis3 = np.random.choice(np.arange(o.shape[2]), o.shape[2], replace).reshape(1, 1, -1)\n return o[axis1, axis2, axis3]\n\ndef rotate_axis0(o, steps=1):\n return o[np.arange(o.shape[0]) - steps]\n\ndef rotate_axis1(o, steps=1):\n return o[:, np.arange(o.shape[1]) - steps]\n\ndef rotate_axis2(o, steps=1):\n return o[:, :, np.arange(o.shape[2]) - steps]",
"_____no_output_____"
],
[
"a = np.tile(np.arange(10), 3).reshape(3, 10) * np.array([1, 10, 100]).reshape(-1, 1)\na",
"_____no_output_____"
],
[
"roll2d(a, roll1=[2, 1, 0])",
"_____no_output_____"
],
[
"roll2d(a, roll2=3)",
"_____no_output_____"
],
[
"o = torch.arange(24).reshape(2,3,4)\ntest_eq(rotate_axis0(o)[1], o[0])\ntest_eq(rotate_axis1(o)[:,1], o[:,0])\ntest_eq(rotate_axis2(o)[...,1], o[...,0])",
"_____no_output_____"
],
[
"#export\ndef chunks_calculator(shape, dtype='float32', n_bytes=1024**3):\n \"\"\"Function to calculate chunks for a given size of n_bytes (default = 1024**3 == 1GB). \n It guarantees > 50% of the chunk will be filled\"\"\"\n \n X = np.random.rand(1, *shape[1:]).astype(dtype)\n byts = get_size(X, return_str=False)\n n = n_bytes // byts\n if shape[0] / n <= 1: return False\n remainder = shape[0] % n\n if remainder / n < .5: \n n_chunks = shape[0] // n\n n += np.ceil(remainder / n_chunks).astype(int)\n return (n, -1, -1)",
"_____no_output_____"
],
[
"shape = (1_000, 10, 1000)\ndtype = 'float32'\ntest_eq(chunks_calculator(shape, dtype), False)\n\nshape = (54684, 10, 1000)\ndtype = 'float32'\ntest_eq(chunks_calculator(shape, dtype), (27342, -1, -1))",
"_____no_output_____"
],
[
"#export\ndef is_memory_shared(a, b):\n r\"\"\"Test function to check if 2 array-like object share memory. \n Be careful because it changes their values!!!)\"\"\"\n \n try: \n a[:] = 1\n except: \n try: \n b[:] = 1\n except: \n print('unknown')\n return \n return torch.equal(tensor(a), tensor(b))",
"_____no_output_____"
],
[
"a = np.random.rand(2,3,4)\nt1 = torch.from_numpy(a)\ntest_eq(is_memory_shared(a, t1), True)\na = np.random.rand(2,3,4)\nt2 = torch.as_tensor(a)\ntest_eq(is_memory_shared(a, t2), True)\na = np.random.rand(2,3,4)\nt3 = torch.tensor(a)\ntest_eq(is_memory_shared(a, t3), False)",
"_____no_output_____"
],
[
"#export\ndef assign_in_chunks(a, b, chunksize='auto', inplace=True, verbose=True):\n \"\"\"Assigns values in b to an array-like object a using chunks to avoid memory overload.\n \n The resulting a retains it's dtype and share it's memory.\n a: array-like object\n b: may be an integer, float, str, 'rand' (for random data), or another array like object.\n chunksize: is the size of chunks. If 'auto' chunks will have around 1GB each. \n \"\"\"\n \n if b != 'rand' and not isinstance(b, (Iterable, Generator)):\n a[:] = b\n else:\n shape = a.shape\n dtype = a.dtype\n if chunksize == \"auto\": \n chunksize = chunks_calculator(shape, dtype)\n chunksize = shape[0] if not chunksize else chunksize[0]\n for i in progress_bar(range((shape[0] - 1) // chunksize + 1), display=verbose, leave=False):\n start, end = i * chunksize, min(shape[0], (i + 1) * chunksize)\n if start >= shape[0]: break\n if b == 'rand': \n a[start:end] = np.random.rand(end - start, *shape[1:])\n else: \n a[start:end] = b[start:end]\n if not inplace: return a",
"_____no_output_____"
],
[
"a = np.random.rand(10,3,4).astype('float32')\na_dtype = a.dtype\na_id = id(a)\nb = np.random.rand(10,3,4).astype('float64')\nassign_in_chunks(a, b, chunksize=2, inplace=True, verbose=True)\ntest_close(a, b)\ntest_eq(a.dtype, a_dtype)\ntest_eq(id(a), a_id)\n\na = np.random.rand(10,3,4).astype('float32')\na_dtype = a.dtype\na_id = id(a)\nb = 1\nassign_in_chunks(a, b, chunksize=2, inplace=True, verbose=True)\ntest_eq(a, np.ones_like(a).astype(a.dtype))\ntest_eq(a.dtype, a_dtype)\ntest_eq(id(a), a_id)\n\na = np.random.rand(10,3,4).astype('float32')\na_dtype = a.dtype\na_id = id(a)\nb = 0.5\nassign_in_chunks(a, b, chunksize=2, inplace=True, verbose=True)\ntest_eq(a.dtype, a_dtype)\ntest_eq(id(a), a_id)\n\na = np.random.rand(10,3,4).astype('float32')\na_dtype = a.dtype\na_id = id(a)\nb = 'rand'\nassign_in_chunks(a, b, chunksize=2, inplace=True, verbose=True)\ntest_eq(a.dtype, a_dtype)\ntest_eq(id(a), a_id)",
"/Users/nacho/opt/anaconda3/envs/py37torch110/lib/python3.7/site-packages/ipykernel_launcher.py:11: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n # This is added back by InteractiveShellApp.init_path()\n"
],
[
"a = np.random.rand(10,3,4).astype('float32')\nb = np.random.rand(10,3,4).astype('float64')\nc = assign_in_chunks(a, b, chunksize=2, inplace=False, verbose=True)\ntest_close(c, b)\ntest_eq(a.dtype, c.dtype)\ntest_eq(is_memory_shared(a, c), True)\n\na = np.random.rand(10,3,4).astype('float32')\nb = 1\nc = assign_in_chunks(a, b, chunksize=2, inplace=False, verbose=True)\ntest_eq(a, np.ones_like(a).astype(a.dtype))\ntest_eq(a.dtype, c.dtype)\ntest_eq(is_memory_shared(a, c), True)\n\na = np.random.rand(10,3,4).astype('float32')\nb = 0.5\nc = assign_in_chunks(a, b, chunksize=2, inplace=False, verbose=True)\ntest_eq(a.dtype, c.dtype)\ntest_eq(is_memory_shared(a, c), True)\n\na = np.random.rand(10,3,4).astype('float32')\nb = 'rand'\nc = assign_in_chunks(a, b, chunksize=2, inplace=False, verbose=True)\ntest_eq(a.dtype, c.dtype)\ntest_eq(is_memory_shared(a, c), True)",
"/Users/nacho/opt/anaconda3/envs/py37torch110/lib/python3.7/site-packages/ipykernel_launcher.py:11: FutureWarning: elementwise comparison failed; returning scalar instead, but in the future will perform elementwise comparison\n # This is added back by InteractiveShellApp.init_path()\n"
],
[
"#export\ndef create_array(shape, fname=None, path='./data', on_disk=True, dtype='float32', mode='r+', fill_value='rand', chunksize='auto', verbose=True, **kwargs):\n \"\"\"\n mode:\n ‘r’: Open existing file for reading only.\n ‘r+’: Open existing file for reading and writing.\n ‘w+’: Create or overwrite existing file for reading and writing.\n ‘c’: Copy-on-write: assignments affect data in memory, but changes are not saved to disk. The file on disk is read-only.\n fill_value: 'rand' (for random numbers), int or float\n chunksize = 'auto' to calculate chunks of 1GB, or any integer (for a given number of samples)\n \"\"\"\n if on_disk:\n assert fname is not None, 'you must provide a fname (filename)'\n path = Path(path)\n if not fname.endswith('npy'): fname = f'{fname}.npy'\n filename = path/fname\n filename.parent.mkdir(parents=True, exist_ok=True)\n # Save a small empty array\n _temp_fn = path/'temp_X.npy'\n np.save(_temp_fn, np.empty(0))\n # Create & save file\n arr = np.memmap(_temp_fn, dtype=dtype, mode='w+', shape=shape, **kwargs)\n np.save(filename, arr)\n del arr\n os.remove(_temp_fn)\n # Open file in selected mode\n arr = np.load(filename, mmap_mode=mode)\n else:\n arr = np.empty(shape, dtype=dtype, **kwargs)\n if fill_value != 0:\n assign_in_chunks(arr, fill_value, chunksize=chunksize, inplace=True, verbose=verbose)\n return arr\n\ncreate_empty_array = partial(create_array, fill_value=0)",
"_____no_output_____"
],
[
"fname = 'X_on_disk'\nshape = (100, 10, 10)\nX = create_array(shape, fname, on_disk=True, mode='r+')\ntest_ne(abs(X).sum(), 0)\nos.remove(X.filename)\ndel X",
"_____no_output_____"
],
[
"fname = 'X_on_disk'\nshape = (100, 10, 10)\nX = create_empty_array(shape, fname, on_disk=True, mode='r+')\ntest_eq(abs(X).sum(), 0)\n\nchunksize = 10\npbar = progress_bar(range(math.ceil(len(X) / chunksize)), leave=False)\nstart = 0\nfor i in pbar: \n end = min(start + chunksize, len(X))\n partial_data = np.random.rand(end - start, X.shape[1] , X.shape[2])\n X[start:end] = partial_data\n start = end\n del partial_data\n gc.collect()\nfilename = X.filename\ndel X\nX = np.load(filename, mmap_mode='r+')\ntest_eq((X == 0).sum(), 0)\ntest_eq(X.shape, shape)\nos.remove(X.filename)\ndel X",
"_____no_output_____"
],
[
"#export\nimport gzip\n\ndef np_save_compressed(arr, fname=None, path='./data', verbose=False, **kwargs):\n assert fname is not None, 'you must provide a fname (filename)'\n if fname.endswith('npy'): fname = f'{fname}.gz'\n elif not fname.endswith('npy.gz'): fname = f'{fname}.npy.gz'\n filename = Path(path)/fname\n filename.parent.mkdir(parents=True, exist_ok=True)\n f = gzip.GzipFile(filename, 'w', **kwargs)\n np.save(file=f, arr=arr)\n f.close()\n pv(f'array saved to {filename}', verbose)\n \ndef np_load_compressed(fname=None, path='./data', **kwargs):\n assert fname is not None, 'you must provide a fname (filename)'\n if fname.endswith('npy'): fname = f'{fname}.gz'\n elif not fname.endswith('npy.gz'): fname = f'{fname}.npy.gz'\n filename = Path(path)/fname\n f = gzip.GzipFile(filename, 'r', **kwargs)\n arr = np.load(f)\n f.close()\n return arr",
"_____no_output_____"
],
[
"X1 = np.random.rand(10)\nnp_save_compressed(X1, 'X_comp', path='./data')\nX2 = np_load_compressed('X_comp')\ntest_eq(X1, X2)",
"_____no_output_____"
],
[
"#export\ndef np2memmap(arr, fname=None, path='./data', dtype='float32', mode='c', **kwargs):\n \"\"\" Function that turns an ndarray into a memmap ndarray\n mode:\n ‘r’: Open existing file for reading only.\n ‘r+’: Open existing file for reading and writing.\n ‘w+’: Create or overwrite existing file for reading and writing.\n ‘c’: Copy-on-write: assignments affect data in memory, but changes are not saved to disk. The file on disk is read-only.\n \"\"\"\n assert fname is not None, 'you must provide a fname (filename)'\n if not fname.endswith('npy'): fname = f'{fname}.npy'\n filename = Path(path)/fname\n filename.parent.mkdir(parents=True, exist_ok=True)\n # Save file\n np.save(filename, arr)\n # Open file in selected mode\n arr = np.load(filename, mmap_mode=mode)\n return arr",
"_____no_output_____"
],
[
"X1 = np.random.rand(10)\nX2 = np2memmap(X1, 'X1_test')\ntest_eq(X1, X2)\ntest_ne(type(X1), type(X2))",
"_____no_output_____"
],
[
"#export \ndef torch_mean_groupby(o, idxs):\n \"\"\"Computes torch mean along axis 0 grouped by the idxs. \n Need to ensure that idxs have the same order as o\"\"\"\n if is_listy(idxs[0]): idxs = flatten_list(idxs)\n flattened_idxs = torch.tensor(idxs)\n idxs, vals = torch.unique(flattened_idxs, return_counts=True)\n vs = torch.split_with_sizes(o, tuple(vals))\n return torch.cat([v.mean(0).unsqueeze(0) for k,v in zip(idxs, vs)])",
"_____no_output_____"
],
[
"o = torch.arange(6*2*3).reshape(6, 2, 3).float()\nidxs = np.array([[0,1,2,3], [2,3]], dtype=object)\noutput = torch_mean_groupby(o, idxs)\ntest_eq(o[:2], output[:2])\ntest_eq(o[2:4].mean(0), output[2])\ntest_eq(o[4:6].mean(0), output[3])",
"_____no_output_____"
],
[
"#export\ndef torch_flip(t, dims=-1):\n if dims == -1: return t[..., np.arange(t.shape[dims])[::-1].copy()]\n elif dims == 0: return t[np.arange(t.shape[dims])[::-1].copy()]\n elif dims == 1: return t[:, np.arange(t.shape[dims])[::-1].copy()]\n elif dims == 2: return t[:, :, np.arange(t.shape[dims])[::-1].copy()]",
"_____no_output_____"
],
[
"t = torch.randn(2, 3, 4)\ntest_eq(torch.flip(t, (2,)), torch_flip(t, dims=-1))",
"_____no_output_____"
],
[
"#export \ndef torch_nan_to_num(o, num=0, inplace=False):\n if ismin_torch(\"1.8\") and not inplace: \n return torch.nan_to_num(o, num)\n mask = torch.isnan(o)\n return torch_masked_to_num(o, mask, num=num, inplace=inplace)\n\ndef torch_masked_to_num(o, mask, num=0, inplace=False):\n if inplace: \n o[:] = o.masked_fill(mask, num)\n else: \n return o.masked_fill(mask, num)",
"_____no_output_____"
],
[
"x = torch.rand(2, 4, 6)\nx[:, :3][x[:, :3] < .5] = np.nan\nnan_values = torch.isnan(x).sum()\ny = torch_nan_to_num(x[:, :3], inplace=False)\ntest_eq(torch.isnan(y).sum(), 0)\ntest_eq(torch.isnan(x).sum(), nan_values)\ntorch_nan_to_num(x[:, :3], inplace=True)\ntest_eq(torch.isnan(x).sum(), 0)",
"_____no_output_____"
],
[
"x = torch.rand(2, 4, 6)\nmask = x[:, :3] > .5\nx[:, :3] = torch_masked_to_num(x[:, :3], mask, num=0, inplace=False)\ntest_eq(x[:, :3][mask].sum(), 0)",
"_____no_output_____"
],
[
"x = torch.rand(2, 4, 6)\nmask = x[:, :3] > .5\ntorch_masked_to_num(x[:, :3], mask, num=0, inplace=True)\ntest_eq(x[:, :3][mask].sum(), 0)",
"_____no_output_____"
],
[
"#export\ndef mpl_trend(x, y, deg=1): \n return np.poly1d(np.polyfit(x, y, deg))(x)",
"_____no_output_____"
],
[
"x = np.sort(np.random.randint(0, 100, 100)/10)\ny = np.random.rand(100) + np.linspace(0, 10, 100)\ntrend = mpl_trend(x, y)\nplt.scatter(x, y)\nplt.plot(x, trend, 'r')\nplt.show()",
"_____no_output_____"
],
[
"#export\ndef int2digits(o, n_digits=None, normalize=True):\n if n_digits is not None:\n iterable = '0' * (n_digits - len(str(abs(o)))) + str(abs(o))\n else:\n iterable = str(abs(o))\n sign = np.sign(o)\n digits = np.array([sign * int(d) for d in iterable])\n if normalize:\n digits = digits / 10\n return digits\n\n\ndef array2digits(o, n_digits=None, normalize=True):\n output = np.array(list(map(partial(int2digits, n_digits=n_digits), o)))\n if normalize:\n output = output / 10\n return output",
"_____no_output_____"
],
[
"o = -9645\ntest_eq(int2digits(o, 6), np.array([ 0, 0, -.9, -.6, -.4, -.5]))\n\na = np.random.randint(-1000, 1000, 10)\ntest_eq(array2digits(a,5).shape, (10,5))",
"_____no_output_____"
],
[
"#export\ndef sincos_encoding(seq_len, device=None, to_np=False):\n if to_np:\n sin = np.sin(np.arange(seq_len) / seq_len * 2 * np.pi)\n cos = np.cos(np.arange(seq_len) / seq_len * 2 * np.pi)\n else:\n if device is None: device = default_device()\n sin = torch.sin(torch.arange(seq_len, device=device) / seq_len * 2 * np.pi)\n cos = torch.cos(torch.arange(seq_len, device=device) / seq_len * 2 * np.pi)\n return sin, cos",
"_____no_output_____"
],
[
"sin, cos = sincos_encoding(100)\nplt.plot(sin.cpu().numpy())\nplt.plot(cos.cpu().numpy())\nplt.show()",
"_____no_output_____"
],
[
"#export\ndef linear_encoding(seq_len, device=None, to_np=False, lin_range=(-1,1)):\n if to_np:\n enc = np.linspace(lin_range[0], lin_range[1], seq_len)\n else:\n if device is None: device = default_device()\n enc = torch.linspace(lin_range[0], lin_range[1], seq_len, device=device)\n return enc",
"_____no_output_____"
],
[
"lin = linear_encoding(100)\nplt.plot(lin.cpu().numpy())\nplt.show()",
"_____no_output_____"
],
[
"#export\ndef encode_positions(pos_arr, min_val=None, max_val=None, linear=False, lin_range=(-1,1)):\n \"\"\" Encodes an array with positions using a linear or sincos methods\n \"\"\"\n \n if min_val is None:\n min_val = np.nanmin(pos_arr)\n if max_val is None:\n max_val = np.nanmax(pos_arr)\n \n if linear: \n return (((pos_arr - min_val)/(max_val - min_val)) * (lin_range[1] - lin_range[0]) + lin_range[0])\n else:\n sin = np.sin((pos_arr - min_val)/(max_val - min_val) * 2 * np.pi)\n cos = np.cos((pos_arr - min_val)/(max_val - min_val) * 2 * np.pi)\n return sin, cos",
"_____no_output_____"
],
[
"n_samples = 10\nlength = 500\n_a = []\nfor i in range(n_samples):\n a = np.arange(-4000, 4000, 10)\n mask = np.random.rand(len(a)) > .5\n a = a[mask]\n a = np.concatenate([a, np.array([np.nan] * (length - len(a)))])\n _a.append(a.reshape(-1,1))\na = np.concatenate(_a, -1).transpose(1,0)\nsin, cos = encode_positions(a, linear=False)\ntest_eq(a.shape, (n_samples, length))\ntest_eq(sin.shape, (n_samples, length))\ntest_eq(cos.shape, (n_samples, length))\nplt.plot(sin.T)\nplt.plot(cos.T)\nplt.xlim(0, 500)\nplt.show()",
"_____no_output_____"
],
[
"n_samples = 10\nlength = 500\n_a = []\nfor i in range(n_samples):\n a = np.arange(-4000, 4000, 10)\n mask = np.random.rand(len(a)) > .5\n a = a[mask]\n a = np.concatenate([a, np.array([np.nan] * (length - len(a)))])\n _a.append(a.reshape(-1,1))\na = np.concatenate(_a, -1).transpose(1,0)\nlin = encode_positions(a, linear=True)\ntest_eq(a.shape, (n_samples, length))\ntest_eq(lin.shape, (n_samples, length))\nplt.plot(lin.T)\nplt.xlim(0, 500)\nplt.show()",
"_____no_output_____"
],
[
"#export\ndef sort_generator(generator, bs):\n g = list(generator)\n for i in range(len(g)//bs + 1): g[bs*i:bs*(i+1)] = np.sort(g[bs*i:bs*(i+1)])\n return (i for i in g)",
"_____no_output_____"
],
[
"generator = (i for i in np.random.permutation(np.arange(1000000)).tolist())\nl = list(sort_generator(generator, 512))\ntest_eq(l[:512], sorted(l[:512]))",
"_____no_output_____"
],
[
"#export\ndef get_subset_dict(d, keys):\n return dict((k,d[k]) for k in listify(keys) if k in d)",
"_____no_output_____"
],
[
"keys = string.ascii_lowercase\nvalues = np.arange(len(keys))\nd = {k:v for k,v in zip(keys,values)}\ntest_eq(get_subset_dict(d, ['a', 'k', 'j', 'e']), {'a': 0, 'k': 10, 'j': 9, 'e': 4})",
"_____no_output_____"
],
[
"#export\ndef create_dir(directory, verbose=True): \n if not is_listy(directory): directory = [directory]\n for d in directory:\n d = Path(d)\n if d.exists():\n if verbose: print(f\"{d} directory already exists.\")\n else: \n d.mkdir(parents=True, exist_ok=True)\n assert d.exists(), f\"a problem has occurred while creating {d}\"\n if verbose: print(f\"{d} directory created.\")\n\n\ndef remove_dir(directory, verbose=True):\n import shutil\n if not is_listy(directory): directory = [directory]\n for d in directory:\n d = Path(d)\n if d.is_file(): d = d.parent\n if not d.exists():\n if verbose: print(f\"{d} directory doesn't exist.\")\n else:\n shutil.rmtree(d)\n assert not d.exists(), f\"a problem has occurred while deleting {d}\"\n if verbose: print(f\"{d} directory removed.\")",
"_____no_output_____"
],
[
"path = \"wandb3/wandb2/wandb\"\ncreate_dir(path)\nassert Path(path).exists()\n\npaths = [\"wandb3/wandb2/wandb\", \"wandb3/wandb2\", \"wandb\"]\nremove_dir(paths)\nfor p in paths: \n assert not Path(p).exists()\n\npath = \"wandb3\"\nassert Path(path).exists()\nremove_dir(path)\nassert not Path(path).exists()",
"wandb3/wandb2/wandb directory created.\nwandb3/wandb2/wandb directory removed.\nwandb3/wandb2 directory removed.\nwandb directory doesn't exist.\nwandb3 directory removed.\n"
],
[
"create_dir('./test')",
"test directory created.\n"
],
[
"%%file ./test/mod_dev.py\na = 5\ndef fn(b): return a + b",
"Writing ./test/mod_dev.py\n"
],
[
"fname = \"./test/mod_dev.py\"\nwhile True: \n if fname[0] in \"/ .\": fname = fname.split(fname[0], 1)[1]\n else: break\nif '/' in fname and fname.rsplit('/', 1)[0] not in sys.path: sys.path.append(fname.rsplit('/', 1)[0])\nmod = import_file_as_module(fname)\ntest_eq(mod.fn(3), 8)\nsys.path = sys.path[:-1]\nremove_dir('./test/')",
"test directory removed.\n"
],
[
"#export\nclass named_partial(object):\n \"\"\"Create a partial function with a __name__\"\"\"\n \n def __init__(self, name, func, *args, **kwargs):\n self._func = partial(func, *args, **kwargs)\n self.__name__ = name\n def __call__(self, *args, **kwargs):\n return self._func(*args, **kwargs)\n def __repr__(self):\n return self.__name__",
"_____no_output_____"
],
[
"def add_1(x, add=1): return x+add\ntest_eq(add_1(1), 2)\nadd_2 = partial(add_1, add=2)\ntest_eq(add_2(2), 4)\ntest_ne(str(add_2), \"add_2\")\nadd_2 = named_partial('add_2', add_1, add=2)\ntest_eq(add_2(2), 4)\ntest_eq(str(add_2), \"add_2\")\n\nclass _A():\n def __init__(self, add=1): self.add = add\n def __call__(self, x): return x + self.add\n \ntest_eq(_A()(1), 2)\n_A2 = partial(_A, add=2)\ntest_eq(_A2()(1), 3)\ntest_ne(str(_A2), '_A2')\n_A2 = named_partial('_A2', _A, add=2)\ntest_eq(_A2()(1), 3)\ntest_eq(str(_A2), '_A2')",
"_____no_output_____"
],
[
"# export\ndef yaml2dict(fname):\n import yaml\n with maybe_open(fname, 'r') as f:\n dictionary = yaml.safe_load(f)\n return AttrDict(dictionary)",
"_____no_output_____"
],
[
"%%file sweep_config.yaml\n\nprogram: wandb_scripts/train_script.py # (required) Path to training script.\nmethod: bayes # (required) Specify the search strategy: grid, random or bayes\nparameters: # (required) Specify parameters bounds to search.\n bs:\n values: [32, 64, 128]\n depth:\n values: [3, 6, 9, 12]\n fc_dropout:\n distribution: uniform\n min: 0.\n max: 0.5\n lr_max:\n values: [0.001, 0.003, 0.01, 0.03, 0.1]\n n_epoch:\n values: [10, 15, 20]\n nb_filters:\n values: [32, 64, 128]\nname: LSST_sweep_01\nmetric: \n name: accuracy # This must match one of the metrics in the training script\n goal: maximize\nearly_terminate: \n type: hyperband\n min_iter: 3\nproject: LSST_wandb_hpo",
"Writing sweep_config.yaml\n"
],
[
"fname = \"sweep_config.yaml\"\nsweep_config = yaml2dict(fname)\nprint(sweep_config)\ntest_eq(sweep_config.method, 'bayes')\ntest_eq(sweep_config['metric'], {'name': 'accuracy', 'goal': 'maximize'})\nos.remove(fname)",
"- program: wandb_scripts/train_script.py\n- method: bayes\n- parameters: \n - bs: \n - values: \n - 32\n - 64\n - 128\n - depth: \n - values: \n - 3\n - 6\n - 9\n - 12\n - fc_dropout: \n - distribution: uniform\n - min: 0.0\n - max: 0.5\n - lr_max: \n - values: \n - 0.001\n - 0.003\n - 0.01\n - 0.03\n - 0.1\n - n_epoch: \n - values: \n - 10\n - 15\n - 20\n - nb_filters: \n - values: \n - 32\n - 64\n - 128\n- name: LSST_sweep_01\n- metric: \n - name: accuracy\n - goal: maximize\n- early_terminate: \n - type: hyperband\n - min_iter: 3\n- project: LSST_wandb_hpo\n"
],
[
"#export\ndef str2list(o):\n if o is None: return []\n elif o is not None and not isinstance(o, (list, L)):\n if isinstance(o, pd.core.indexes.base.Index): o = o.tolist()\n else: o = [o]\n return o\n\ndef str2index(o):\n if o is None: return o\n o = str2list(o)\n if len(o) == 1: return o[0]\n return o\n\ndef get_cont_cols(df):\n return df._get_numeric_data().columns.tolist()\n\ndef get_cat_cols(df):\n cols = df.columns.tolist()\n cont_cols = df._get_numeric_data().columns.tolist()\n return [col for col in cols if col not in cont_cols]",
"_____no_output_____"
],
[
"#export\nalphabet = L(list(string.ascii_lowercase))\nALPHABET = L(list(string.ascii_uppercase))",
"_____no_output_____"
],
[
"#export\ndef get_mapping(arr, dim=1, return_counts=False):\n maps = [L(np.unique(np.take(arr, i, dim)).tolist()) for i in range(arr.shape[dim])]\n if return_counts:\n counts = [len(m) for m in maps]\n return maps, counts\n return maps\n\ndef map_array(arr, dim=1):\n out = stack([np.unique(np.take(arr, i, dim), return_inverse=True)[1] for i in range(arr.shape[dim])])\n if dim == 1: out = out.T\n return out",
"_____no_output_____"
],
[
"a = np.asarray(alphabet[np.random.randint(0,15,30)]).reshape(10,3)\nb = np.asarray(ALPHABET[np.random.randint(6,10,30)]).reshape(10,3)\nx = concat(a,b,dim=1)\nmaps, counts = get_mapping(x, dim=1, return_counts=True)\nx, maps, counts",
"_____no_output_____"
],
[
"x = np.asarray(alphabet[np.random.randint(0,15,30)]).reshape(10,3)\nx, map_array(x), map_array(x, 1)",
"_____no_output_____"
],
[
"# export\ndef log_tfm(o, inplace=False):\n \"Log transforms an array-like object with positive and/or negative values\"\n if isinstance(o, torch.Tensor):\n pos_o = torch.log1p(o[o > 0])\n neg_o = -torch.log1p(torch.abs(o[o < 0]))\n else: \n pos_o = np.log1p(o[o > 0])\n neg_o = -np.log1p(np.abs(o[o < 0]))\n if inplace:\n o[o > 0] = pos_o\n o[o < 0] = neg_o\n return o\n else:\n if hasattr(o, \"clone\"): output = o.clone()\n elif hasattr(o, \"copy\"): output = o.copy()\n output[output > 0] = pos_o\n output[output < 0] = neg_o\n return output",
"_____no_output_____"
],
[
"arr = np.asarray([-1000, -100, -10, -1, 0, 1, 10, 100, 1000]).astype(float)\nplt.plot(arr, log_tfm(arr, False))\nplt.show()",
"_____no_output_____"
],
[
"t = tensor([-1000, -100, -10, -1, 0, 1, 10, 100, 1000]).float()\nplt.plot(t, log_tfm(t, False))\nplt.show()",
"_____no_output_____"
],
[
"#export\ndef to_sincos_time(arr, max_value):\n sin = np.sin(arr / max_value * 2 * np.pi)\n cos = np.cos(arr / max_value * 2 * np.pi)\n return sin, cos",
"_____no_output_____"
],
[
"arr = np.sort(np.random.rand(100) * 5)\narr_sin, arr_cos = to_sincos_time(arr, 5)\nplt.scatter(arr, arr_sin)\nplt.scatter(arr, arr_cos)\nplt.show()",
"_____no_output_____"
],
[
"#export\ndef plot_feature_dist(X, percentiles=[0,0.1,0.5,1,5,10,25,50,75,90,95,99,99.5,99.9,100]):\n for i in range(X.shape[1]):\n ys = []\n for p in percentiles:\n ys.append(np.percentile(X[:, i].flatten(), p))\n plt.plot(percentiles, ys)\n plt.xticks(percentiles, rotation='vertical')\n plt.grid(color='gainsboro', linewidth=.5)\n plt.title(f\"var_{i}\")\n plt.show()",
"_____no_output_____"
],
[
"arr = np.random.rand(10, 3, 100)\nplot_feature_dist(arr, percentiles=[0,0.1,0.5,1,5,10,25,50,75,90,95,99,99.5,99.9,100])",
"_____no_output_____"
],
[
"#export\ndef rolling_moving_average(o, window=2):\n if isinstance(o, torch.Tensor):\n cunsum = torch.cumsum(o, axis=-1) # nancumsum not available (can't be used with missing data!)\n lag_cunsum = torch.cat([torch.zeros((o.shape[0], o.shape[1], window), device=o.device), torch.cumsum(o[..., :-window], axis=-1)], -1)\n count = torch.clip(torch.ones_like(o).cumsum(-1), max=window)\n return (cunsum - lag_cunsum) / count\n else:\n cunsum = np.nancumsum(o, axis=-1)\n lag_cunsum = np.concatenate([np.zeros((o.shape[0], o.shape[1], window)), np.nancumsum(o[..., :-window], axis=-1)], -1)\n count = np.minimum(np.ones_like(o).cumsum(-1), window)\n return (cunsum - lag_cunsum) / count",
"_____no_output_____"
],
[
"a = np.arange(60).reshape(2,3,10).astype(float)\nt = torch.arange(60).reshape(2,3,10).float()\ntest_close(rolling_moving_average(a, window=3), rolling_moving_average(t, window=3).numpy())\nprint(t)\nprint(rolling_moving_average(t, window=3))",
"tensor([[[ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.],\n [10., 11., 12., 13., 14., 15., 16., 17., 18., 19.],\n [20., 21., 22., 23., 24., 25., 26., 27., 28., 29.]],\n\n [[30., 31., 32., 33., 34., 35., 36., 37., 38., 39.],\n [40., 41., 42., 43., 44., 45., 46., 47., 48., 49.],\n [50., 51., 52., 53., 54., 55., 56., 57., 58., 59.]]])\ntensor([[[ 0.0000, 0.5000, 1.0000, 2.0000, 3.0000, 4.0000, 5.0000,\n 6.0000, 7.0000, 8.0000],\n [10.0000, 10.5000, 11.0000, 12.0000, 13.0000, 14.0000, 15.0000,\n 16.0000, 17.0000, 18.0000],\n [20.0000, 20.5000, 21.0000, 22.0000, 23.0000, 24.0000, 25.0000,\n 26.0000, 27.0000, 28.0000]],\n\n [[30.0000, 30.5000, 31.0000, 32.0000, 33.0000, 34.0000, 35.0000,\n 36.0000, 37.0000, 38.0000],\n [40.0000, 40.5000, 41.0000, 42.0000, 43.0000, 44.0000, 45.0000,\n 46.0000, 47.0000, 48.0000],\n [50.0000, 50.5000, 51.0000, 52.0000, 53.0000, 54.0000, 55.0000,\n 56.0000, 57.0000, 58.0000]]])\n"
],
[
"#export\ndef ffill_sequence(o):\n \"\"\"Forward fills an array-like object alongside sequence dimension\"\"\"\n if isinstance(o, torch.Tensor):\n mask = torch.isnan(o)\n idx = torch.where(~mask, torch.arange(mask.shape[-1], device=o.device), 0)\n idx = torch.cummax(idx, dim=-1).values\n return o[torch.arange(o.shape[0], device=o.device)[:,None,None], torch.arange(o.shape[1], device=o.device)[None,:,None], idx]\n else:\n mask = np.isnan(o)\n idx = np.where(~mask, np.arange(mask.shape[-1]), 0)\n idx = np.maximum.accumulate(idx, axis=-1)\n return o[np.arange(o.shape[0])[:,None,None], np.arange(o.shape[1])[None,:,None], idx]\n\ndef bfill_sequence(o):\n \"\"\"Backward fills an array-like object alongside sequence dimension\"\"\"\n if isinstance(o, torch.Tensor):\n o = torch.flip(o, (-1,))\n o = ffill_sequence(o)\n return torch.flip(o, (-1,))\n else:\n o = o[..., ::-1]\n o = ffill_sequence(o)\n return o[..., ::-1]\n\ndef fbfill_sequence(o):\n \"\"\"Forward and backward fills an array-like object alongside sequence dimension\"\"\"\n o = ffill_sequence(o)\n o = bfill_sequence(o)\n return o",
"_____no_output_____"
],
[
"a = np.arange(80).reshape(2, 4, 10).astype(float)\nmask = np.random.rand(*a.shape)\na[mask > .8] = np.nan\nt = torch.from_numpy(a)\nt",
"_____no_output_____"
],
[
"# forward fill\nfilled_a = ffill_sequence(a)\nprint(filled_a)\nm = np.isnan(filled_a)\ntest_eq(filled_a[~m], ffill_sequence(t).numpy()[~m])",
"[[[ 0. 1. 2. 3. 3. 5. 6. 7. 8. 9.]\n [10. 11. 12. 13. 14. 14. 16. 17. 17. 19.]\n [20. 21. 22. 23. 23. 25. 26. 26. 28. 29.]\n [30. 31. 32. 33. 34. 35. 36. 37. 38. 39.]]\n\n [[40. 41. 42. 42. 42. 45. 45. 47. 48. 48.]\n [50. 51. 52. 53. 54. 55. 56. 56. 56. 59.]\n [60. 61. 62. 63. 64. 65. 65. 67. 68. 69.]\n [70. 71. 72. 72. 74. 75. 76. 77. 77. 79.]]]\n"
],
[
"# backward fill\nfilled_a = bfill_sequence(a)\nprint(filled_a)\nm = np.isnan(filled_a)\ntest_eq(filled_a[~m], bfill_sequence(t).numpy()[~m])",
"[[[ 0. 1. 2. 3. 5. 5. 6. 7. 8. 9.]\n [10. 11. 12. 13. 14. 16. 16. 17. 19. 19.]\n [20. 21. 22. 23. 25. 25. 26. 28. 28. 29.]\n [30. 31. 32. 33. 34. 35. 36. 37. 38. 39.]]\n\n [[40. 41. 42. 45. 45. 45. 47. 47. 48. nan]\n [50. 51. 52. 53. 54. 55. 56. 59. 59. 59.]\n [60. 61. 62. 63. 64. 65. 67. 67. 68. 69.]\n [70. 71. 72. 74. 74. 75. 76. 77. 79. 79.]]]\n"
],
[
"# forward & backward fill\nfilled_a = fbfill_sequence(a)\nprint(filled_a)\nm = np.isnan(filled_a)\ntest_eq(filled_a[~m], fbfill_sequence(t).numpy()[~m])",
"[[[ 0. 1. 2. 3. 3. 5. 6. 7. 8. 9.]\n [10. 11. 12. 13. 14. 14. 16. 17. 17. 19.]\n [20. 21. 22. 23. 23. 25. 26. 26. 28. 29.]\n [30. 31. 32. 33. 34. 35. 36. 37. 38. 39.]]\n\n [[40. 41. 42. 42. 42. 45. 45. 47. 48. 48.]\n [50. 51. 52. 53. 54. 55. 56. 56. 56. 59.]\n [60. 61. 62. 63. 64. 65. 65. 67. 68. 69.]\n [70. 71. 72. 72. 74. 75. 76. 77. 77. 79.]]]\n"
],
[
"#export\ndef dummify(o:Union[np.ndarray, torch.Tensor], by_var:bool=True, inplace:bool=False, skip:Optional[list]=None, random_state=None):\n \"\"\"Shuffles an array-like object along all dimensions or dimension 1 (variables) if by_var is True.\"\"\"\n if not inplace: \n if isinstance(o, np.ndarray): o_dummy = o.copy()\n elif isinstance(o, torch.Tensor): o_dummy = o.clone()\n else: o_dummy = o\n if by_var:\n for k in progress_bar(range(o.shape[1]), leave=False):\n if skip is not None and k in listify(skip): continue\n o_dummy[:, k] = random_shuffle(o[:, k].flatten(), random_state=random_state).reshape(o[:, k].shape)\n else:\n o_dummy[:] = random_shuffle(o.flatten(), random_state=random_state).reshape(o.shape)\n if not inplace: \n return o_dummy",
"_____no_output_____"
],
[
"arr = np.random.rand(2,3,10)\narr_original = arr.copy()\ndummy_arr = dummify(arr)\ntest_ne(arr_original, dummy_arr)\ntest_eq(arr_original, arr)\ndummify(arr, inplace=True)\ntest_ne(arr_original, arr)",
"_____no_output_____"
],
[
"t = torch.rand(2,3,10)\nt_original = t.clone()\ndummy_t = dummify(t)\ntest_ne(t_original, dummy_t)\ntest_eq(t_original, t)\ndummify(t, inplace=True)\ntest_ne(t_original, t)",
"_____no_output_____"
],
[
"#export\ndef shuffle_along_axis(o, axis=-1, random_state=None):\n if isinstance(o, torch.Tensor): size = o.numel()\n else: size = np.size(o)\n for ax in listify(axis):\n idx = random_shuffle(np.arange(size), random_state=random_state).reshape(*o.shape).argsort(axis=ax)\n o = np.take_along_axis(o, idx, axis=ax)\n return o",
"_____no_output_____"
],
[
"X = np.arange(60).reshape(2,3,10) + 10\nX_shuffled = shuffle_along_axis(X,(0, -1), random_state=23)\ntest_eq(X_shuffled, np.array([[[13, 15, 41, 14, 40, 49, 18, 42, 47, 46],\n [28, 56, 53, 50, 52, 25, 24, 57, 51, 59],\n [34, 30, 38, 35, 69, 66, 63, 67, 61, 62]],\n\n [[19, 10, 11, 16, 43, 12, 17, 48, 45, 44],\n [23, 20, 26, 22, 21, 27, 58, 29, 54, 55],\n [36, 31, 39, 60, 33, 68, 37, 32, 65, 64]]]))",
"_____no_output_____"
],
[
"# export\ndef analyze_feature(feature, bins=100, density=False, feature_name=None, clip_outliers_plot=False, quantile_range=(25.0, 75.0), \n percentiles=[1, 25, 50, 75, 99], text_len=12, figsize=(10,6)):\n non_nan_feature = feature[~np.isnan(feature)]\n nan_perc = np.isnan(feature).mean()\n print(f\"{'dtype':>{text_len}}: {feature.dtype}\")\n print(f\"{'nan values':>{text_len}}: {nan_perc:.1%}\")\n print(f\"{'max':>{text_len}}: {np.nanmax(feature)}\")\n for p in percentiles:\n print(f\"{p:>{text_len}.0f}: {get_percentile(feature, p)}\")\n print(f\"{'min':>{text_len}}: {np.nanmin(feature)}\")\n min_outliers, max_outliers = get_outliers_IQR(feature, quantile_range=quantile_range)\n print(f\"{'outlier min':>{text_len}}: {min_outliers}\")\n print(f\"{'outlier max':>{text_len}}: {max_outliers}\")\n print(f\"{'outliers':>{text_len}}: {((non_nan_feature < min_outliers) | (non_nan_feature > max_outliers)).mean():.1%}\")\n print(f\"{'mean':>{text_len}}: {np.nanmean(feature)}\")\n print(f\"{'std':>{text_len}}: {np.nanstd(feature)}\")\n print(f\"{'normal dist':>{text_len}}: {normaltest(non_nan_feature, axis=0, nan_policy='propagate')[1] > .05}\")\n plt.figure(figsize=figsize)\n if clip_outliers_plot:\n plt.hist(np.clip(non_nan_feature, min_outliers, max_outliers), bins, density=density, color='lime', edgecolor='black')\n else: \n plt.hist(non_nan_feature, bins, density=density, color='lime', edgecolor='black')\n plt.axvline(min_outliers, lw=1, ls='--', color='red')\n plt.axvline(max_outliers, lw=1, ls='--', color='red')\n plt.title(f\"feature: {feature_name}\")\n plt.show()\n \ndef analyze_array(o, bins=100, density=False, feature_names=None, clip_outliers_plot=False, quantile_range=(25.0, 75.0), \n percentiles=[1, 25, 50, 75, 99], text_len=12, figsize=(10,6)):\n if percentiles:\n percentiles = np.sort(percentiles)[::-1]\n print(f\"{'array shape':>{text_len}}: {o.shape}\")\n if o.ndim > 1:\n for f in range(o.shape[1]):\n feature_name = f\"{feature_names[f]}\" if feature_names is not None else f\n print(f\"\\n{f:3} {'feature':>{text_len - 4}}: {feature_name}\\n\")\n analyze_feature(o[:, f].flatten(), feature_name=feature_name)\n else:\n analyze_feature(o.flatten(), feature_name=feature_names) ",
"_____no_output_____"
],
[
"x = np.random.normal(size=(1000))\nanalyze_array(x)",
" array shape: (1000,)\n dtype: float64\n nan values: 0.0%\n max: 2.8962792292643007\n 1: -2.120764247253952\n 25: -0.6776624311119962\n 50: 0.03797148808519438\n 75: 0.6837275374444655\n 99: 2.116961348657088\n min: -3.23432018653886\n outlier min: -2.7197473839466886\n outlier max: 2.725812490279158\n outliers: 0.5%\n mean: 0.030734294784013245\n std: 0.9799586630237788\n normal dist: True\n"
],
[
"x1 = np.random.normal(size=(1000,2))\nx2 = np.random.normal(3, 5, size=(1000,2))\nx = x1 + x2\nanalyze_array(x)",
" array shape: (1000, 2)\n\n 0 feature: 0\n\n dtype: float64\n nan values: 0.0%\n max: 22.193197926165894\n 1: -8.938044186311068\n 25: -0.6161653903943344\n 50: 2.64602402345483\n 75: 6.355462078190231\n 99: 15.520739262450803\n min: -11.708551852753047\n outlier min: -11.073606593271183\n outlier max: 16.81290328106708\n outliers: 0.7%\n mean: 2.899962696597163\n std: 5.23084401171235\n normal dist: True\n"
],
[
"#export\ndef get_relpath(path):\n current_path = os.getcwd()\n if is_listy(path):\n relpaths = []\n for p in path:\n relpaths.append(os.path.relpath(p, current_path))\n return relpaths\n else:\n return os.path.relpath(path, current_path)",
"_____no_output_____"
],
[
"#hide\nfrom tsai.imports import *\nfrom tsai.export import *\nnb_name = get_nb_name()\n# nb_name = \"001_utils.ipynb\"\ncreate_scripts(nb_name);",
"_____no_output_____"
]
]
] | [
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"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",
"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"
]
] |
ece8632579b72fdd8b67dbffb497668f2e5c717d | 6,824 | ipynb | Jupyter Notebook | .ipynb_checkpoints/google_translate_api-checkpoint.ipynb | anir16293/MarcoSearch | 6c1f3932057e8b55f43bb61ee32d94fc149ad82e | [
"MIT"
] | 1 | 2019-09-16T22:33:49.000Z | 2019-09-16T22:33:49.000Z | google_translate_api.ipynb | anir16293/MarcoSearch | 6c1f3932057e8b55f43bb61ee32d94fc149ad82e | [
"MIT"
] | null | null | null | google_translate_api.ipynb | anir16293/MarcoSearch | 6c1f3932057e8b55f43bb61ee32d94fc149ad82e | [
"MIT"
] | null | null | null | 89.789474 | 1,808 | 0.672333 | [
[
[
"from googletrans import Translator",
"_____no_output_____"
],
[
"translator = Translator()",
"_____no_output_____"
],
[
"translator.detect('kk')",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code"
]
] |
ece863ecba647303b8f0182b06f45b0d755f909c | 7,360 | ipynb | Jupyter Notebook | Notebook 2, Graphical Error Modelling.ipynb | pranav-ust/cognates | c1924e6daa7fb4367ca72e37f613be60ea2fbca5 | [
"MIT"
] | 4 | 2018-11-25T18:50:13.000Z | 2022-02-05T01:32:59.000Z | Notebook 2, Graphical Error Modelling.ipynb | pranav-ust/cognates | c1924e6daa7fb4367ca72e37f613be60ea2fbca5 | [
"MIT"
] | null | null | null | Notebook 2, Graphical Error Modelling.ipynb | pranav-ust/cognates | c1924e6daa7fb4367ca72e37f613be60ea2fbca5 | [
"MIT"
] | null | null | null | 32.566372 | 182 | 0.550815 | [
[
[
"# Graphical Error Modelling",
"_____no_output_____"
],
[
"This notebook details about algorithms discussed in section 3 of the paper, \"Alignment Analysis of Sequential Segmentation of Lexicons to Improve Automatic Cognate Detection\"",
"_____no_output_____"
],
[
"## Imports",
"_____no_output_____"
],
[
"The function `common_elements` will carry out the operation of set intersection and `uncommon_elements` will carry out the operation of set difference.",
"_____no_output_____"
]
],
[
[
"from math import ceil, floor\n\ndef common_elements(list1, list2):\n ''' Carries out set intersection '''\n return [element for element in list1 if element in list2]\n\ndef uncommon_elements(list1, list2):\n ''' Carries out set difference '''\n return [element for element in list1 if element not in list2]",
"_____no_output_____"
]
],
[
[
"We import the functions from the previous notebook which are `shingle` and `two_ends`.",
"_____no_output_____"
]
],
[
[
"def shingle(input, k):\n ''' Shingles the input into k-grams '''\n k = min(len(input), k)\n start_combinations = [input[:i] for i in range(1, k)]\n kgrams = [input[i:i + k] for i in range(len(input) - k + 1)]\n end_combinations = [input[-i:] for i in range(k - 1, 0, -1)]\n return start_combinations + kgrams + end_combinations\n\ndef two_ends(input, k):\n ''' Shingles the input into k-grams but encodes numbers from two ends '''\n basic = shingle(input, k)\n result =[]\n for i in range(1, len(basic) + 1):\n if i <= (len(input) - i + 2):\n result.append(str(i) + basic[i - 1]) # Append numbers from start\n else:\n result.append(basic[i - 1] + str(len(basic) - i + 1)) # Append numbers from end\n return result",
"_____no_output_____"
]
],
[
[
"## Graphical Modelling Algorithm",
"_____no_output_____"
],
[
"The algorithm consists of three parts:\n1. Initialization\n2. Equalization of the set cardinalities\n3. Inserting the mappings of the set members into the graph\n\nThis algorithm returns the graphical structure between two shingle sets.",
"_____no_output_____"
]
],
[
[
"def graph_model(first, second):\n ''' Constructs the graphical structure between two shingle sets. '''\n \n # Step 1: Initialization\n # If the given sets first and second are empty, we initialize \n # them by inserting an empty token, (nun), into those sets.\n \n if len(first) == 0:\n first.append(\"nun\") #insert empty token if found empty\n if len(second) == 0:\n second.append(\"nun\") #insert empty token if found empty\n \n # Step 2: Equalization of the set cardinalities\n # The cardinalities of the sets first and second made\n # equal by inserting empty tokens (nun) into the\n # middle of the sets.\n \n # While loops to equalize the sizes\n while(len(first) < len(second)):\n pos = ceil(len(first) / 2)\n first.insert(pos, \"nun\")\n \n # While loops to equalize the sizes\n while(len(first) > len(second)):\n pos = floor(len(second) / 2)\n second.insert(pos, \"nun\")\n \n # Step 3: Inserting the mappings of the set members into the graph\n # The empty graph is initialized as graph = {}.\n # The directed edges are generated, originating from every set member\n # of first to every set member of second. This results in a complete \n # directed bipartite graph between first and second sets.\n \n # Pairs in tuples\n graph = set() #Graph in sets to avoid duplicates\n \n for i in range(len(first)):\n pair = (first[i], second[i]) # One to one mapping with same index\n graph.add(pair)\n for i in range(len(first) - 1):\n pair = (first[i], second[i + 1]) # One to one mapping with an index ahead\n graph.add(pair)\n if len(first) > 1:\n for i in range(1, len(first)):\n pair = (first[i], second[i - 1]) # One to one mapping with an index before\n graph.add(pair)\n return graph",
"_____no_output_____"
]
],
[
[
"## Playing with the functions ",
"_____no_output_____"
],
[
"Let the source cognate be *mesia* and target cognate be *messia*.\n\nFirstly, we will shingle them using `two_ends` function.\n\nUsing the `common_elements` function, we would find $S \\cap T$.\n\nUsing the `uncommon_elements` function, we would find $S - (S \\cap T)$, which would form the *top*.\n\nUsing the `uncommon_elements` function, we would find $T - (S \\cap T)$, which would form the *bottom*.\n\nUsing the `graph_model` function, the graph would be outputted.",
"_____no_output_____"
]
],
[
[
"source = two_ends(\"mesia\", 2) # Source cognate\ntarget = two_ends(\"messia\", 2) # Target cognate\nprint(source, target)\nst = common_elements(source, target) # s cap t\ntop = uncommon_elements(source, st) # s - (s cap t)\nbottom = uncommon_elements(target, st) # t - (s cap t)\nprint(\"Top and bottom are\", top, bottom)\nprint(\"Graph is \", graph_model(top, bottom))",
"_____no_output_____"
]
],
[
[
"We get the graph as `{('nun', '4ss')}`, which means as $\\phi \\rightarrow 4ss$.\nIntuitively, $\\phi \\rightarrow 4ss$ means that if the letter s is added at position 4 of the word of the source *mesia*, then one could get the target word *messia*.",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
]
] |
ece864b317a34ddf08f32b30a7cdee8233a2cc37 | 108,318 | ipynb | Jupyter Notebook | Multiple_sclerosis_detection_K_fold_3D_intersection_data_preparation.ipynb | abr-98/segmentation_for_multiple_Scleorisis_Detection | ec147d662d5184df3afe2a810bb3619438a52ee0 | [
"MIT"
] | null | null | null | Multiple_sclerosis_detection_K_fold_3D_intersection_data_preparation.ipynb | abr-98/segmentation_for_multiple_Scleorisis_Detection | ec147d662d5184df3afe2a810bb3619438a52ee0 | [
"MIT"
] | null | null | null | Multiple_sclerosis_detection_K_fold_3D_intersection_data_preparation.ipynb | abr-98/segmentation_for_multiple_Scleorisis_Detection | ec147d662d5184df3afe2a810bb3619438a52ee0 | [
"MIT"
] | null | null | null | 23.795694 | 483 | 0.300144 | [
[
[
"## Mounter",
"_____no_output_____"
]
],
[
[
"from google.colab import drive\ndrive.mount('/content/drive')",
"Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n\nEnter your authorization code:\n··········\nMounted at /content/drive\n"
]
],
[
[
"## Function Declaration",
"_____no_output_____"
]
],
[
[
"import tensorflow as tf\nimport numpy as np\nimport os\nimport nibabel as nib\nimport cv2 as cv\nimport matplotlib.pyplot as plt\n \ndef modality(Path,index):\n X = []\n X_per_paitent = []\n p=os.listdir(Path) \n recs_in=[]\n counter=0\n counter_2=0\n\n for i in p[:14]: # Loading all the folders in the given path\n q = os.listdir(os.path.join(Path,i)) \n\n x = nib.load(os.path.join(Path,i,q[index])) \n f = x.get_fdata()\n f = np.asarray(f,'float32')\n \n ct=0\n recs_in.append(f.shape[2])\n #print(counter_2)\n counter_2+=1\n for j in range(f.shape[2]): # Processing the MRI Scan in the axial view\n _slice = cv.resize(f[:,:,j],(256,256),interpolation=cv.INTER_NEAREST) # Resizing the slice to the shape(256,256)\n if(index not in [3,4,5,6,7,8,9] and np.sum(_slice) != 0 ): \n if index==1:\n ct+=1 \n counter+=1 # To check whether the slice is null or not\n # _slice = _slice / (np.max(_slice) + 0.00001) # Normalization\n _slice = (_slice - np.mean(_slice) + 0.00001) / (np.std(_slice) + 0.00001)\n # Standardization\n else:\n # To check whether the slice is null or not\n # _slice = _slice / (np.max(_slice) + 0.00001) # Normalization\n _slice = (_slice - np.mean(_slice) + 0.00001) / (np.std(_slice) + 0.00001) # Standardization\n elif(index in [3,4,5,6,7,8,9]): # if index = 3, Then it is output mask and we don't normalize or standardize it \n _slice = np.array(_slice)\n _slice[_slice > 0] = 1.0\n _slice[_slice < 0] = 0.0\n _slice = _slice.T\n _slice = _slice[:,:,np.newaxis]\n X.append(_slice)\n # X=np.array(X,dtype='float32')\n return X,recs_in",
"_____no_output_____"
],
[
"def remove_null_samples(X_Dp, X_Flair, X_Gado, X_T1, X_T2, Y_Manual,recs): \n \n X=[]\n Y=[]\n counter=0\n counter_2=0\n mult=0;\n count=0\n rec=[]\n keep_count=[]\n keep=[]\n print(recs)\n r=np.array(recs,dtype='float32')\n print(np.sum(r))\n print(len(X_Dp))\n\n for i in range(len(X_Dp)): \n if counter==(recs[mult]):\n print(counter)\n mult+=1\n rec.append(count)\n counter=0\n print(counter_2)\n count=0\n final_slice = np.concatenate((X_Dp[i],X_Flair[i],X_Gado[i],X_T1[i],X_T2[i]), axis = -1)\n if(np.sum(final_slice) != 0): # checking whether the final slice is empty or not \n X.append(final_slice)\n Y.append(Y_Manual[i])\n \n count+=1\n counter+=1\n counter_2+=1\n\n \n rec.append(count)\n# Converting the list into array \n X=np.array(X,dtype='float32')\n Y=np.array(Y,dtype='float32')\n rec=np.array(rec,dtype='float32')\n \n return X,Y,rec\n",
"_____no_output_____"
],
[
"def store_data(X,Y,rec):\n np.save(\"drive/My Drive/MS_data/X_intersection_new.npy\",X)\n np.save(\"drive/My Drive/MS_data/Y_intersection_new.npy\",Y)\n np.save(\"drive/My Drive/MS_data/intersection_new_rec_after_removal.npy\",rec)",
"_____no_output_____"
],
[
"import math\ndef intersection(Y_1,Y_2,Y_3,Y_4,Y_5,Y_6,Y_7):\n Y=[]\n sum2=[]\n flag=0\n #y=np.array()\n print(\"A\")\n for i in range (len(Y_1)):\n #print(Y_1[i])\n \n f=np.concatenate((Y_1[i],Y_2[i],Y_3[i],Y_4[i],Y_5[i],Y_6[i],Y_7[i]),axis=-1)\n sum=np.sum(f,axis=2)\n # print(sum)\n \n #print(j)\n sum_1=np.divide(sum,7)\n sum_1=np.floor(sum_1)\n sum2.append(sum_1)\n\n #sum2=np.array(sum2,dtype='float32')\n \n \n return sum2\n ",
"_____no_output_____"
]
],
[
[
"## Data Preprocessing",
"_____no_output_____"
]
],
[
[
"import numpy as np\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\nfrom sklearn.model_selection import train_test_split\n\n#import keras\nfrom tensorflow.keras.models import Model, load_model\nfrom tensorflow.keras.layers import Input ,BatchNormalization , Activation \nfrom tensorflow.keras.layers import Conv2D, UpSampling2D\nfrom tensorflow.keras.layers import MaxPooling2D\nfrom tensorflow.keras.layers import concatenate\nfrom tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint\nfrom tensorflow.keras.optimizers import Adam\nfrom sklearn.model_selection import train_test_split\n\n\n#import dataPrepare as process\n# Loading all the 5 different modalities of each MRI Scan of all 15 different patients and 1st rater Manual SegmentationX_Dp = modality(Path,0)\n#import Modified_UNet \n#import plots\n#import Metrics\n\n# Setting the path\nPath='drive/My Drive/Pre-processed'\n\n\n\n# Loading all the 5 different modalities of each MRI Scan of all 15 different patients and 1st rater Manual Segmentation\nX_Dp_t,rec = modality(Path,0)\nX_Flair_t,rec_1 = modality(Path,1)\nX_Gado_t,rec = modality(Path,2)\nX_T1_t,rec = modality(Path,10)\nX_T2_t,rec = modality(Path,11)\nrec=np.array(rec_1,dtype='float32')\nnp.save(\"drive/My Drive/MS_data/intersection_new_rec_before_removal.npy\",rec)",
"_____no_output_____"
],
[
"import numpy as np\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\nfrom sklearn.model_selection import train_test_split\n\n#import keras\nfrom tensorflow.keras.models import Model, load_model\nfrom tensorflow.keras.layers import Input ,BatchNormalization , Activation \nfrom tensorflow.keras.layers import Conv2D, UpSampling2D\nfrom tensorflow.keras.layers import MaxPooling2D\nfrom tensorflow.keras.layers import concatenate\nfrom tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint\nfrom tensorflow.keras.optimizers import Adam\nfrom sklearn.model_selection import train_test_split\n\n\n#import dataPrepare as process\n# Loading all the 5 different modalities of each MRI Scan of all 15 different patients and 1st rater Manual SegmentationX_Dp = modality(Path,0)\n#import Modified_UNet \n#import plots\n#import Metrics\n\n# Setting the path\nPath='drive/My Drive/Pre-processed'\nY_1,rec = modality(Path,3)\nY_2,rec = modality(Path,4)\nY_3,rec = modality(Path,5)\nY_4,rec = modality(Path,6)\nY_5,rec = modality(Path,7)\nY_6,rec = modality(Path,8)\nY_7,rec = modality(Path,9)",
"_____no_output_____"
],
[
"Y_Manual=intersection(Y_1,Y_2,Y_3,Y_4,Y_5,Y_6,Y_7)",
"A\n"
],
[
"import numpy as np\n\nnp.save(\"drive/My Drive/MS_data/Y_manual_new.npy\",Y_Manual)",
"_____no_output_____"
],
[
"Y_manual=list(Y_Manual)",
"_____no_output_____"
],
[
"Y_Manual=np.load(\"drive/My Drive/MS_data/Y_manual_new.npy\")",
"_____no_output_____"
],
[
"X, Y,rec = remove_null_samples(X_Dp_t, X_Flair_t, X_Gado_t, X_T1_t, X_T2_t, Y_manual,rec_1)",
"[256, 256, 512, 512, 256, 512, 512, 256, 512, 256, 336, 336, 336, 336]\n5184.0\n5184\n256\n256\n256\n512\n512\n1024\n512\n1536\n256\n1792\n512\n2304\n512\n2816\n256\n3072\n512\n3584\n256\n3840\n336\n4176\n336\n4512\n336\n4848\n"
],
[
"store_data(X,Y,rec)",
"_____no_output_____"
],
[
"import numpy as np\nY=np.load(\"drive/My Drive/MS_data/Y_intersection_new.npy\")",
"_____no_output_____"
],
[
"Y_Manual=list(Y)",
"_____no_output_____"
],
[
"Y_1=Y_Manual[:1401]\nY_2=Y_Manual[1401:]",
"_____no_output_____"
],
[
"p=[]\ny=[]\nz=[]\na=[]\nn=1\nfor i in Y_1:\n print(n)\n for j in i:\n for k in j:\n #print(k)\n a.append(k)\n # print(a)\n z.append(a)\n a=[]\n #print(z)\n y.append(z)\n z=[]\n p.append(y)\n y=[]\n n+=1\n\n\n#print(p)\n",
"_____no_output_____"
],
[
"temp=np.array(p)\nnp.save(\"drive/My Drive/MS_data/temp_1_new.npy\",temp)",
"_____no_output_____"
],
[
"q=[]\ny=[]\nz=[]\na=[]\nn=1401\nfor i in Y_2:\n print(n)\n for j in i:\n for k in j:\n #print(k)\n a.append(k)\n # print(a)\n z.append(a)\n a=[]\n #print(z)\n y.append(z)\n z=[]\n q.append(y)\n y=[]\n n+=1\n",
"1401\n1402\n1403\n1404\n1405\n1406\n1407\n1408\n1409\n1410\n1411\n1412\n1413\n1414\n1415\n1416\n1417\n1418\n1419\n1420\n1421\n1422\n1423\n1424\n1425\n1426\n1427\n1428\n1429\n1430\n1431\n1432\n1433\n1434\n1435\n1436\n1437\n1438\n1439\n1440\n1441\n1442\n1443\n1444\n1445\n1446\n1447\n1448\n1449\n1450\n1451\n1452\n1453\n1454\n1455\n1456\n1457\n1458\n1459\n1460\n1461\n1462\n1463\n1464\n1465\n1466\n1467\n1468\n1469\n1470\n1471\n1472\n1473\n1474\n1475\n1476\n1477\n1478\n1479\n1480\n1481\n1482\n1483\n1484\n1485\n1486\n1487\n1488\n1489\n1490\n1491\n1492\n1493\n1494\n1495\n1496\n1497\n1498\n1499\n1500\n1501\n1502\n1503\n1504\n1505\n1506\n1507\n1508\n1509\n1510\n1511\n1512\n1513\n1514\n1515\n1516\n1517\n1518\n1519\n1520\n1521\n1522\n1523\n1524\n1525\n1526\n1527\n1528\n1529\n1530\n1531\n1532\n1533\n1534\n1535\n1536\n1537\n1538\n1539\n1540\n1541\n1542\n1543\n1544\n1545\n1546\n1547\n1548\n1549\n1550\n1551\n1552\n1553\n1554\n1555\n1556\n1557\n1558\n1559\n1560\n1561\n1562\n1563\n1564\n1565\n1566\n1567\n1568\n1569\n1570\n1571\n1572\n1573\n1574\n1575\n1576\n1577\n1578\n1579\n1580\n1581\n1582\n1583\n1584\n1585\n1586\n1587\n1588\n1589\n1590\n1591\n1592\n1593\n1594\n1595\n1596\n1597\n1598\n1599\n1600\n1601\n1602\n1603\n1604\n1605\n1606\n1607\n1608\n1609\n1610\n1611\n1612\n1613\n1614\n1615\n1616\n1617\n1618\n1619\n1620\n1621\n1622\n1623\n1624\n1625\n1626\n1627\n1628\n1629\n1630\n1631\n1632\n1633\n1634\n1635\n1636\n1637\n1638\n1639\n1640\n1641\n1642\n1643\n1644\n1645\n1646\n1647\n1648\n1649\n1650\n1651\n1652\n1653\n1654\n1655\n1656\n1657\n1658\n1659\n1660\n1661\n1662\n1663\n1664\n1665\n1666\n1667\n1668\n1669\n1670\n1671\n1672\n1673\n1674\n1675\n1676\n1677\n1678\n1679\n1680\n1681\n1682\n1683\n1684\n1685\n1686\n1687\n1688\n1689\n1690\n1691\n1692\n1693\n1694\n1695\n1696\n1697\n1698\n1699\n1700\n1701\n1702\n1703\n1704\n1705\n1706\n1707\n1708\n1709\n1710\n1711\n1712\n1713\n1714\n1715\n1716\n1717\n1718\n1719\n1720\n1721\n1722\n1723\n1724\n1725\n1726\n1727\n1728\n1729\n1730\n1731\n1732\n1733\n1734\n1735\n1736\n1737\n1738\n1739\n1740\n1741\n1742\n1743\n1744\n1745\n1746\n1747\n1748\n1749\n1750\n1751\n1752\n1753\n1754\n1755\n1756\n1757\n1758\n1759\n1760\n1761\n1762\n1763\n1764\n1765\n1766\n1767\n1768\n1769\n1770\n1771\n1772\n1773\n1774\n1775\n1776\n1777\n1778\n1779\n1780\n1781\n1782\n1783\n1784\n1785\n1786\n1787\n1788\n1789\n1790\n1791\n1792\n1793\n1794\n1795\n1796\n1797\n1798\n1799\n1800\n1801\n1802\n1803\n1804\n1805\n1806\n1807\n1808\n1809\n1810\n1811\n1812\n1813\n1814\n1815\n1816\n1817\n1818\n1819\n1820\n1821\n1822\n1823\n1824\n1825\n1826\n1827\n1828\n1829\n1830\n1831\n1832\n1833\n1834\n1835\n1836\n1837\n1838\n1839\n1840\n1841\n1842\n1843\n1844\n1845\n1846\n1847\n1848\n1849\n1850\n1851\n1852\n1853\n1854\n1855\n1856\n1857\n1858\n1859\n1860\n1861\n1862\n1863\n1864\n1865\n1866\n1867\n1868\n1869\n1870\n1871\n1872\n1873\n1874\n1875\n1876\n1877\n1878\n1879\n1880\n1881\n1882\n1883\n1884\n1885\n1886\n1887\n1888\n1889\n1890\n1891\n1892\n1893\n1894\n1895\n1896\n1897\n1898\n1899\n1900\n1901\n1902\n1903\n1904\n1905\n1906\n1907\n1908\n1909\n1910\n1911\n1912\n1913\n1914\n1915\n1916\n1917\n1918\n1919\n1920\n1921\n1922\n1923\n1924\n1925\n1926\n1927\n1928\n1929\n1930\n1931\n1932\n1933\n1934\n1935\n1936\n1937\n1938\n1939\n1940\n1941\n1942\n1943\n1944\n1945\n1946\n1947\n1948\n1949\n1950\n1951\n1952\n1953\n1954\n1955\n1956\n1957\n1958\n1959\n1960\n1961\n1962\n1963\n1964\n1965\n1966\n1967\n1968\n1969\n1970\n1971\n1972\n1973\n1974\n1975\n1976\n1977\n1978\n1979\n1980\n1981\n1982\n1983\n1984\n1985\n1986\n1987\n1988\n1989\n1990\n1991\n1992\n1993\n1994\n1995\n1996\n1997\n1998\n1999\n2000\n2001\n2002\n2003\n2004\n2005\n2006\n2007\n2008\n2009\n2010\n2011\n2012\n2013\n2014\n2015\n2016\n2017\n2018\n2019\n2020\n2021\n2022\n2023\n2024\n2025\n2026\n2027\n2028\n2029\n2030\n2031\n2032\n2033\n2034\n2035\n2036\n2037\n2038\n2039\n2040\n2041\n2042\n2043\n2044\n2045\n2046\n2047\n2048\n2049\n2050\n2051\n2052\n2053\n2054\n2055\n2056\n2057\n2058\n2059\n2060\n2061\n2062\n2063\n2064\n2065\n2066\n2067\n2068\n2069\n2070\n2071\n2072\n2073\n2074\n2075\n2076\n2077\n2078\n2079\n2080\n2081\n2082\n2083\n2084\n2085\n2086\n2087\n2088\n2089\n2090\n2091\n2092\n2093\n2094\n2095\n2096\n2097\n2098\n2099\n2100\n2101\n2102\n2103\n2104\n2105\n2106\n2107\n2108\n2109\n2110\n2111\n2112\n2113\n2114\n2115\n2116\n2117\n2118\n2119\n2120\n2121\n2122\n2123\n2124\n2125\n2126\n2127\n2128\n2129\n2130\n2131\n2132\n2133\n2134\n2135\n2136\n2137\n2138\n2139\n2140\n2141\n2142\n2143\n2144\n2145\n2146\n2147\n2148\n2149\n2150\n2151\n2152\n2153\n2154\n2155\n2156\n2157\n2158\n2159\n2160\n2161\n2162\n2163\n2164\n2165\n2166\n2167\n2168\n2169\n2170\n2171\n2172\n2173\n2174\n2175\n2176\n2177\n2178\n2179\n2180\n2181\n2182\n2183\n2184\n2185\n2186\n2187\n2188\n2189\n2190\n2191\n2192\n2193\n2194\n2195\n2196\n2197\n2198\n2199\n2200\n2201\n2202\n2203\n2204\n2205\n2206\n2207\n2208\n2209\n2210\n2211\n2212\n2213\n2214\n2215\n2216\n2217\n2218\n2219\n2220\n2221\n2222\n2223\n2224\n2225\n2226\n2227\n2228\n2229\n2230\n2231\n2232\n2233\n2234\n2235\n2236\n2237\n2238\n2239\n2240\n2241\n2242\n2243\n2244\n2245\n2246\n2247\n2248\n2249\n2250\n2251\n2252\n2253\n2254\n2255\n2256\n2257\n2258\n2259\n2260\n2261\n2262\n2263\n2264\n2265\n2266\n2267\n2268\n2269\n2270\n2271\n2272\n2273\n2274\n2275\n2276\n2277\n2278\n2279\n2280\n2281\n2282\n2283\n2284\n2285\n2286\n2287\n2288\n2289\n2290\n2291\n2292\n2293\n2294\n2295\n2296\n2297\n2298\n2299\n2300\n2301\n2302\n2303\n2304\n2305\n2306\n2307\n2308\n2309\n2310\n2311\n2312\n2313\n2314\n2315\n2316\n2317\n2318\n2319\n2320\n2321\n2322\n2323\n2324\n2325\n2326\n2327\n2328\n2329\n2330\n2331\n2332\n2333\n2334\n2335\n2336\n2337\n2338\n2339\n2340\n2341\n2342\n2343\n2344\n2345\n2346\n2347\n2348\n2349\n2350\n2351\n2352\n2353\n2354\n2355\n2356\n2357\n2358\n2359\n2360\n2361\n2362\n2363\n2364\n2365\n2366\n2367\n2368\n2369\n2370\n2371\n2372\n2373\n2374\n2375\n2376\n2377\n2378\n2379\n2380\n2381\n2382\n2383\n2384\n2385\n2386\n2387\n2388\n2389\n2390\n2391\n2392\n2393\n2394\n2395\n2396\n2397\n2398\n2399\n2400\n2401\n2402\n2403\n2404\n2405\n2406\n2407\n2408\n2409\n2410\n2411\n2412\n2413\n2414\n2415\n2416\n2417\n2418\n2419\n2420\n2421\n2422\n2423\n2424\n2425\n2426\n2427\n2428\n2429\n2430\n2431\n2432\n2433\n2434\n2435\n2436\n2437\n2438\n2439\n2440\n2441\n2442\n2443\n2444\n2445\n2446\n2447\n2448\n2449\n2450\n2451\n2452\n2453\n2454\n2455\n2456\n2457\n2458\n2459\n2460\n2461\n2462\n2463\n2464\n2465\n2466\n2467\n2468\n2469\n2470\n2471\n2472\n2473\n2474\n2475\n2476\n2477\n2478\n2479\n2480\n2481\n2482\n2483\n2484\n2485\n2486\n2487\n2488\n2489\n2490\n2491\n2492\n2493\n2494\n2495\n2496\n2497\n2498\n2499\n2500\n2501\n2502\n2503\n2504\n2505\n2506\n2507\n2508\n2509\n2510\n2511\n2512\n2513\n2514\n2515\n2516\n2517\n2518\n2519\n2520\n2521\n2522\n2523\n2524\n2525\n2526\n2527\n2528\n2529\n2530\n2531\n2532\n2533\n2534\n2535\n2536\n2537\n2538\n2539\n2540\n2541\n2542\n2543\n2544\n2545\n2546\n2547\n2548\n2549\n2550\n2551\n2552\n2553\n2554\n2555\n2556\n2557\n2558\n2559\n2560\n2561\n2562\n2563\n2564\n2565\n2566\n2567\n2568\n2569\n2570\n2571\n2572\n2573\n2574\n2575\n2576\n2577\n2578\n2579\n2580\n2581\n2582\n2583\n2584\n2585\n2586\n2587\n2588\n2589\n2590\n2591\n2592\n2593\n2594\n2595\n2596\n2597\n2598\n2599\n2600\n2601\n2602\n2603\n2604\n2605\n2606\n2607\n2608\n2609\n2610\n2611\n2612\n2613\n2614\n2615\n2616\n2617\n2618\n2619\n2620\n2621\n2622\n2623\n2624\n2625\n2626\n2627\n2628\n2629\n2630\n2631\n2632\n2633\n2634\n2635\n2636\n2637\n2638\n2639\n2640\n2641\n2642\n2643\n2644\n2645\n2646\n2647\n2648\n2649\n2650\n2651\n2652\n2653\n2654\n2655\n2656\n2657\n2658\n2659\n2660\n2661\n2662\n2663\n2664\n2665\n2666\n2667\n2668\n2669\n2670\n2671\n2672\n2673\n2674\n2675\n2676\n2677\n2678\n2679\n2680\n2681\n2682\n2683\n2684\n2685\n2686\n2687\n2688\n2689\n2690\n2691\n2692\n2693\n2694\n2695\n2696\n2697\n2698\n2699\n2700\n2701\n2702\n2703\n2704\n2705\n2706\n2707\n2708\n2709\n2710\n2711\n2712\n2713\n2714\n2715\n2716\n2717\n2718\n2719\n2720\n2721\n2722\n2723\n2724\n2725\n2726\n2727\n2728\n2729\n2730\n2731\n2732\n2733\n2734\n2735\n2736\n2737\n2738\n2739\n2740\n2741\n2742\n2743\n2744\n2745\n2746\n2747\n2748\n2749\n2750\n2751\n2752\n2753\n2754\n2755\n2756\n2757\n2758\n2759\n2760\n2761\n2762\n2763\n2764\n2765\n2766\n2767\n2768\n2769\n2770\n2771\n2772\n2773\n2774\n2775\n2776\n2777\n2778\n2779\n2780\n2781\n2782\n2783\n2784\n2785\n2786\n2787\n2788\n2789\n2790\n2791\n2792\n2793\n2794\n2795\n2796\n2797\n2798\n2799\n2800\n2801\n2802\n2803\n2804\n2805\n2806\n2807\n2808\n2809\n2810\n2811\n2812\n2813\n2814\n2815\n2816\n2817\n2818\n2819\n2820\n2821\n2822\n2823\n2824\n2825\n2826\n2827\n2828\n2829\n2830\n2831\n2832\n2833\n2834\n2835\n2836\n2837\n2838\n2839\n2840\n2841\n2842\n2843\n2844\n2845\n2846\n2847\n2848\n2849\n2850\n2851\n2852\n2853\n2854\n2855\n2856\n2857\n2858\n2859\n2860\n2861\n2862\n2863\n2864\n2865\n2866\n2867\n2868\n2869\n2870\n2871\n2872\n2873\n2874\n2875\n2876\n2877\n2878\n2879\n2880\n2881\n2882\n2883\n2884\n2885\n2886\n2887\n2888\n2889\n2890\n2891\n2892\n2893\n2894\n2895\n2896\n2897\n2898\n2899\n2900\n2901\n2902\n2903\n2904\n2905\n2906\n2907\n2908\n2909\n2910\n2911\n2912\n2913\n2914\n2915\n2916\n2917\n2918\n2919\n2920\n2921\n2922\n2923\n2924\n2925\n2926\n2927\n2928\n2929\n2930\n2931\n2932\n2933\n2934\n2935\n2936\n2937\n2938\n2939\n"
],
[
"temp2=np.array(q)\nnp.save(\"drive/My Drive/MS_data/temp_2_new.npy\",temp2)",
"_____no_output_____"
],
[
"temp=np.load(\"drive/My Drive/MS_data/temp_1_new.npy\")\np=list(temp)",
"_____no_output_____"
],
[
"temp2=np.load(\"drive/My Drive/MS_data/temp_2_new.npy\")\nq=list(temp2)",
"_____no_output_____"
],
[
"j=1401\nfor i in q:\n print(j)\n p.append(i)\n j+=1",
"1401\n1402\n1403\n1404\n1405\n1406\n1407\n1408\n1409\n1410\n1411\n1412\n1413\n1414\n1415\n1416\n1417\n1418\n1419\n1420\n1421\n1422\n1423\n1424\n1425\n1426\n1427\n1428\n1429\n1430\n1431\n1432\n1433\n1434\n1435\n1436\n1437\n1438\n1439\n1440\n1441\n1442\n1443\n1444\n1445\n1446\n1447\n1448\n1449\n1450\n1451\n1452\n1453\n1454\n1455\n1456\n1457\n1458\n1459\n1460\n1461\n1462\n1463\n1464\n1465\n1466\n1467\n1468\n1469\n1470\n1471\n1472\n1473\n1474\n1475\n1476\n1477\n1478\n1479\n1480\n1481\n1482\n1483\n1484\n1485\n1486\n1487\n1488\n1489\n1490\n1491\n1492\n1493\n1494\n1495\n1496\n1497\n1498\n1499\n1500\n1501\n1502\n1503\n1504\n1505\n1506\n1507\n1508\n1509\n1510\n1511\n1512\n1513\n1514\n1515\n1516\n1517\n1518\n1519\n1520\n1521\n1522\n1523\n1524\n1525\n1526\n1527\n1528\n1529\n1530\n1531\n1532\n1533\n1534\n1535\n1536\n1537\n1538\n1539\n1540\n1541\n1542\n1543\n1544\n1545\n1546\n1547\n1548\n1549\n1550\n1551\n1552\n1553\n1554\n1555\n1556\n1557\n1558\n1559\n1560\n1561\n1562\n1563\n1564\n1565\n1566\n1567\n1568\n1569\n1570\n1571\n1572\n1573\n1574\n1575\n1576\n1577\n1578\n1579\n1580\n1581\n1582\n1583\n1584\n1585\n1586\n1587\n1588\n1589\n1590\n1591\n1592\n1593\n1594\n1595\n1596\n1597\n1598\n1599\n1600\n1601\n1602\n1603\n1604\n1605\n1606\n1607\n1608\n1609\n1610\n1611\n1612\n1613\n1614\n1615\n1616\n1617\n1618\n1619\n1620\n1621\n1622\n1623\n1624\n1625\n1626\n1627\n1628\n1629\n1630\n1631\n1632\n1633\n1634\n1635\n1636\n1637\n1638\n1639\n1640\n1641\n1642\n1643\n1644\n1645\n1646\n1647\n1648\n1649\n1650\n1651\n1652\n1653\n1654\n1655\n1656\n1657\n1658\n1659\n1660\n1661\n1662\n1663\n1664\n1665\n1666\n1667\n1668\n1669\n1670\n1671\n1672\n1673\n1674\n1675\n1676\n1677\n1678\n1679\n1680\n1681\n1682\n1683\n1684\n1685\n1686\n1687\n1688\n1689\n1690\n1691\n1692\n1693\n1694\n1695\n1696\n1697\n1698\n1699\n1700\n1701\n1702\n1703\n1704\n1705\n1706\n1707\n1708\n1709\n1710\n1711\n1712\n1713\n1714\n1715\n1716\n1717\n1718\n1719\n1720\n1721\n1722\n1723\n1724\n1725\n1726\n1727\n1728\n1729\n1730\n1731\n1732\n1733\n1734\n1735\n1736\n1737\n1738\n1739\n1740\n1741\n1742\n1743\n1744\n1745\n1746\n1747\n1748\n1749\n1750\n1751\n1752\n1753\n1754\n1755\n1756\n1757\n1758\n1759\n1760\n1761\n1762\n1763\n1764\n1765\n1766\n1767\n1768\n1769\n1770\n1771\n1772\n1773\n1774\n1775\n1776\n1777\n1778\n1779\n1780\n1781\n1782\n1783\n1784\n1785\n1786\n1787\n1788\n1789\n1790\n1791\n1792\n1793\n1794\n1795\n1796\n1797\n1798\n1799\n1800\n1801\n1802\n1803\n1804\n1805\n1806\n1807\n1808\n1809\n1810\n1811\n1812\n1813\n1814\n1815\n1816\n1817\n1818\n1819\n1820\n1821\n1822\n1823\n1824\n1825\n1826\n1827\n1828\n1829\n1830\n1831\n1832\n1833\n1834\n1835\n1836\n1837\n1838\n1839\n1840\n1841\n1842\n1843\n1844\n1845\n1846\n1847\n1848\n1849\n1850\n1851\n1852\n1853\n1854\n1855\n1856\n1857\n1858\n1859\n1860\n1861\n1862\n1863\n1864\n1865\n1866\n1867\n1868\n1869\n1870\n1871\n1872\n1873\n1874\n1875\n1876\n1877\n1878\n1879\n1880\n1881\n1882\n1883\n1884\n1885\n1886\n1887\n1888\n1889\n1890\n1891\n1892\n1893\n1894\n1895\n1896\n1897\n1898\n1899\n1900\n1901\n1902\n1903\n1904\n1905\n1906\n1907\n1908\n1909\n1910\n1911\n1912\n1913\n1914\n1915\n1916\n1917\n1918\n1919\n1920\n1921\n1922\n1923\n1924\n1925\n1926\n1927\n1928\n1929\n1930\n1931\n1932\n1933\n1934\n1935\n1936\n1937\n1938\n1939\n1940\n1941\n1942\n1943\n1944\n1945\n1946\n1947\n1948\n1949\n1950\n1951\n1952\n1953\n1954\n1955\n1956\n1957\n1958\n1959\n1960\n1961\n1962\n1963\n1964\n1965\n1966\n1967\n1968\n1969\n1970\n1971\n1972\n1973\n1974\n1975\n1976\n1977\n1978\n1979\n1980\n1981\n1982\n1983\n1984\n1985\n1986\n1987\n1988\n1989\n1990\n1991\n1992\n1993\n1994\n1995\n1996\n1997\n1998\n1999\n2000\n2001\n2002\n2003\n2004\n2005\n2006\n2007\n2008\n2009\n2010\n2011\n2012\n2013\n2014\n2015\n2016\n2017\n2018\n2019\n2020\n2021\n2022\n2023\n2024\n2025\n2026\n2027\n2028\n2029\n2030\n2031\n2032\n2033\n2034\n2035\n2036\n2037\n2038\n2039\n2040\n2041\n2042\n2043\n2044\n2045\n2046\n2047\n2048\n2049\n2050\n2051\n2052\n2053\n2054\n2055\n2056\n2057\n2058\n2059\n2060\n2061\n2062\n2063\n2064\n2065\n2066\n2067\n2068\n2069\n2070\n2071\n2072\n2073\n2074\n2075\n2076\n2077\n2078\n2079\n2080\n2081\n2082\n2083\n2084\n2085\n2086\n2087\n2088\n2089\n2090\n2091\n2092\n2093\n2094\n2095\n2096\n2097\n2098\n2099\n2100\n2101\n2102\n2103\n2104\n2105\n2106\n2107\n2108\n2109\n2110\n2111\n2112\n2113\n2114\n2115\n2116\n2117\n2118\n2119\n2120\n2121\n2122\n2123\n2124\n2125\n2126\n2127\n2128\n2129\n2130\n2131\n2132\n2133\n2134\n2135\n2136\n2137\n2138\n2139\n2140\n2141\n2142\n2143\n2144\n2145\n2146\n2147\n2148\n2149\n2150\n2151\n2152\n2153\n2154\n2155\n2156\n2157\n2158\n2159\n2160\n2161\n2162\n2163\n2164\n2165\n2166\n2167\n2168\n2169\n2170\n2171\n2172\n2173\n2174\n2175\n2176\n2177\n2178\n2179\n2180\n2181\n2182\n2183\n2184\n2185\n2186\n2187\n2188\n2189\n2190\n2191\n2192\n2193\n2194\n2195\n2196\n2197\n2198\n2199\n2200\n2201\n2202\n2203\n2204\n2205\n2206\n2207\n2208\n2209\n2210\n2211\n2212\n2213\n2214\n2215\n2216\n2217\n2218\n2219\n2220\n2221\n2222\n2223\n2224\n2225\n2226\n2227\n2228\n2229\n2230\n2231\n2232\n2233\n2234\n2235\n2236\n2237\n2238\n2239\n2240\n2241\n2242\n2243\n2244\n2245\n2246\n2247\n2248\n2249\n2250\n2251\n2252\n2253\n2254\n2255\n2256\n2257\n2258\n2259\n2260\n2261\n2262\n2263\n2264\n2265\n2266\n2267\n2268\n2269\n2270\n2271\n2272\n2273\n2274\n2275\n2276\n2277\n2278\n2279\n2280\n2281\n2282\n2283\n2284\n2285\n2286\n2287\n2288\n2289\n2290\n2291\n2292\n2293\n2294\n2295\n2296\n2297\n2298\n2299\n2300\n2301\n2302\n2303\n2304\n2305\n2306\n2307\n2308\n2309\n2310\n2311\n2312\n2313\n2314\n2315\n2316\n2317\n2318\n2319\n2320\n2321\n2322\n2323\n2324\n2325\n2326\n2327\n2328\n2329\n2330\n2331\n2332\n2333\n2334\n2335\n2336\n2337\n2338\n2339\n2340\n2341\n2342\n2343\n2344\n2345\n2346\n2347\n2348\n2349\n2350\n2351\n2352\n2353\n2354\n2355\n2356\n2357\n2358\n2359\n2360\n2361\n2362\n2363\n2364\n2365\n2366\n2367\n2368\n2369\n2370\n2371\n2372\n2373\n2374\n2375\n2376\n2377\n2378\n2379\n2380\n2381\n2382\n2383\n2384\n2385\n2386\n2387\n2388\n2389\n2390\n2391\n2392\n2393\n2394\n2395\n2396\n2397\n2398\n2399\n2400\n2401\n2402\n2403\n2404\n2405\n2406\n2407\n2408\n2409\n2410\n2411\n2412\n2413\n2414\n2415\n2416\n2417\n2418\n2419\n2420\n2421\n2422\n2423\n2424\n2425\n2426\n2427\n2428\n2429\n2430\n2431\n2432\n2433\n2434\n2435\n2436\n2437\n2438\n2439\n2440\n2441\n2442\n2443\n2444\n2445\n2446\n2447\n2448\n2449\n2450\n2451\n2452\n2453\n2454\n2455\n2456\n2457\n2458\n2459\n2460\n2461\n2462\n2463\n2464\n2465\n2466\n2467\n2468\n2469\n2470\n2471\n2472\n2473\n2474\n2475\n2476\n2477\n2478\n2479\n2480\n2481\n2482\n2483\n2484\n2485\n2486\n2487\n2488\n2489\n2490\n2491\n2492\n2493\n2494\n2495\n2496\n2497\n2498\n2499\n2500\n2501\n2502\n2503\n2504\n2505\n2506\n2507\n2508\n2509\n2510\n2511\n2512\n2513\n2514\n2515\n2516\n2517\n2518\n2519\n2520\n2521\n2522\n2523\n2524\n2525\n2526\n2527\n2528\n2529\n2530\n2531\n2532\n2533\n2534\n2535\n2536\n2537\n2538\n2539\n2540\n2541\n2542\n2543\n2544\n2545\n2546\n2547\n2548\n2549\n2550\n2551\n2552\n2553\n2554\n2555\n2556\n2557\n2558\n2559\n2560\n2561\n2562\n2563\n2564\n2565\n2566\n2567\n2568\n2569\n2570\n2571\n2572\n2573\n2574\n2575\n2576\n2577\n2578\n2579\n2580\n2581\n2582\n2583\n2584\n2585\n2586\n2587\n2588\n2589\n2590\n2591\n2592\n2593\n2594\n2595\n2596\n2597\n2598\n2599\n2600\n2601\n2602\n2603\n2604\n2605\n2606\n2607\n2608\n2609\n2610\n2611\n2612\n2613\n2614\n2615\n2616\n2617\n2618\n2619\n2620\n2621\n2622\n2623\n2624\n2625\n2626\n2627\n2628\n2629\n2630\n2631\n2632\n2633\n2634\n2635\n2636\n2637\n2638\n2639\n2640\n2641\n2642\n2643\n2644\n2645\n2646\n2647\n2648\n2649\n2650\n2651\n2652\n2653\n2654\n2655\n2656\n2657\n2658\n2659\n2660\n2661\n2662\n2663\n2664\n2665\n2666\n2667\n2668\n2669\n2670\n2671\n2672\n2673\n2674\n2675\n2676\n2677\n2678\n2679\n2680\n2681\n2682\n2683\n2684\n2685\n2686\n2687\n2688\n2689\n2690\n2691\n2692\n2693\n2694\n2695\n2696\n2697\n2698\n2699\n2700\n2701\n2702\n2703\n2704\n2705\n2706\n2707\n2708\n2709\n2710\n2711\n2712\n2713\n2714\n2715\n2716\n2717\n2718\n2719\n2720\n2721\n2722\n2723\n2724\n2725\n2726\n2727\n2728\n2729\n2730\n2731\n2732\n2733\n2734\n2735\n2736\n2737\n2738\n2739\n2740\n2741\n2742\n2743\n2744\n2745\n2746\n2747\n2748\n2749\n2750\n2751\n2752\n2753\n2754\n2755\n2756\n2757\n2758\n2759\n2760\n2761\n2762\n2763\n2764\n2765\n2766\n2767\n2768\n2769\n2770\n2771\n2772\n2773\n2774\n2775\n2776\n2777\n2778\n2779\n2780\n2781\n2782\n2783\n2784\n2785\n2786\n2787\n2788\n2789\n2790\n2791\n2792\n2793\n2794\n2795\n2796\n2797\n2798\n2799\n2800\n2801\n2802\n2803\n2804\n2805\n2806\n2807\n2808\n2809\n2810\n2811\n2812\n2813\n2814\n2815\n2816\n2817\n2818\n2819\n2820\n2821\n2822\n2823\n2824\n2825\n2826\n2827\n2828\n2829\n2830\n2831\n2832\n2833\n2834\n2835\n2836\n2837\n2838\n2839\n2840\n2841\n2842\n2843\n2844\n2845\n2846\n2847\n2848\n2849\n2850\n2851\n2852\n2853\n2854\n2855\n2856\n2857\n2858\n2859\n2860\n2861\n2862\n2863\n2864\n2865\n2866\n2867\n2868\n2869\n2870\n2871\n2872\n2873\n2874\n2875\n2876\n2877\n2878\n2879\n2880\n2881\n2882\n2883\n2884\n2885\n2886\n2887\n2888\n2889\n2890\n2891\n2892\n2893\n2894\n2895\n2896\n2897\n2898\n2899\n2900\n2901\n2902\n2903\n2904\n2905\n2906\n2907\n2908\n2909\n2910\n2911\n2912\n2913\n2914\n2915\n2916\n2917\n2918\n2919\n2920\n2921\n2922\n2923\n2924\n2925\n2926\n2927\n2928\n2929\n2930\n2931\n2932\n2933\n2934\n2935\n2936\n2937\n2938\n2939\n"
],
[
"np.save(\"drive/My Drive/MS_data/Y_Manual_2_new.npy\",p)",
"_____no_output_____"
],
[
"import numpy as np\n\nP=np.load(\"drive/My Drive/MS_data/Y_Manual_2_new.npy\")",
"_____no_output_____"
],
[
"Y=p",
"_____no_output_____"
],
[
"Y=list(Y)",
"_____no_output_____"
],
[
"dummy_y=[]\nd_temp_1=[]\nd_temp_2=[]\nfor i in range(len(Y[0])):\n d_temp_1=[]\n for j in range(len(Y[0][0])):\n d_temp_2=[]\n for k in range(len(Y[0][0][0])):\n d_temp_2.append(0.)\n d_temp_1.append(d_temp_2)\n dummy_y.append(d_temp_1)\nY_dummy=np.array(dummy_y, dtype='float32')\n\n\n\n ",
"_____no_output_____"
],
[
"X=np.load(\"drive/My Drive/MS_data/X_intersection_new.npy\")",
"_____no_output_____"
],
[
"X=list(X)",
"_____no_output_____"
],
[
"dummy_x=[]\nd_temp_1=[]\nd_temp_2=[]\nfor i in range(len(X[0])):\n d_temp_1=[]\n for j in range(len(X[0][0])):\n d_temp_2=[]\n for k in range(len(X[0][0][0])):\n d_temp_2.append(0.)\n d_temp_1.append(d_temp_2)\n dummy_x.append(d_temp_1)\nX_dummy=np.array(dummy_x, dtype='float32')",
"_____no_output_____"
],
[
"import numpy as np\n\n#Y=np.load(\"drive/My Drive/MS_data/Y_Manual_2_new.npy\")\nX=np.load(\"drive/My Drive/MS_data/X_intersection_new.npy\")",
"_____no_output_____"
],
[
"X=list(X)",
"_____no_output_____"
],
[
"extra=[0,1,6,4,6,0,5,0,4,3,1,3,3,0]",
"_____no_output_____"
],
[
"ext=np.array(extra,dtype='float32')",
"_____no_output_____"
],
[
"r=np.load(\"drive/My Drive/MS_data/intersection_new_rec_after_removal.npy\")",
"_____no_output_____"
],
[
"rec=list(r)",
"_____no_output_____"
],
[
"j=0\nindex=0\nfor i in extra:\n k=0\n \n print(i)\n index=index+rec[j]\n j+=1\n while(k<i):\n index=index+k\n print(index)\n index=int(index)\n Y.insert(index,Y_dummy)\n X.insert(index,X_dummy)\n\n k+=1",
"0\n1\n279.0\n6\n561.0\n562\n564\n567\n571\n576\n4\n844.0\n845\n847\n850\n6\n988.0\n989\n991\n994\n998\n1003\n0\n5\n1590.0\n1591\n1593\n1596\n1600\n0\n4\n2036.0\n2037\n2039\n2042\n3\n2183.0\n2184\n2186\n1\n2377.0\n3\n2598.0\n2599\n2601\n3\n2782.0\n2783\n2785\n0\n"
],
[
"rec=list(r)\nX=list(X)\nY=list(Y)",
"_____no_output_____"
],
[
"X=np.array(X,dtype='float32')\nY=np.array(Y,dtype='float32')\n",
"_____no_output_____"
],
[
"np.save(\"drive/My Drive/MS_data/Actual_X.npy\",X)\nnp.save(\"drive/My Drive/MS_data/Actual_Y.npy\",Y)",
"_____no_output_____"
],
[
"import numpy as np\n\nY=np.load(\"drive/My Drive/MS_data/Actual_X.npy\")\nX=np.load(\"drive/My Drive/MS_data/Actual_Y.npy\")",
"_____no_output_____"
],
[
"X_1=[]\nY_1=[]",
"_____no_output_____"
],
[
"X=list(X)\nY=list(Y)",
"_____no_output_____"
],
[
"index_x_p=0\nlength=8\nindex_x=length\nindex_y_p=0\nindex_y=length\nx_temp=[]\ny_temp=[]\n\n",
"_____no_output_____"
],
[
"while index_x<=len(X) and index_y<=len(Y):\n x_temp=X[index_x_p:index_x]\n y_temp=Y[index_y_p:index_y]\n x_temp_1=np.array(x_temp,dtype='float32')\n y_temp_1=np.array(y_temp,dtype='float32')\n X_1.append(x_temp_1)\n Y_1.append(y_temp_1)\n index_y_p=index_y_p+length\n index_x_p=index_x_p+length\n index_x=index_x+length\n index_y=index_y+length\n",
"_____no_output_____"
],
[
"X_1=np.array(X_1,dtype='float32')\nY_1=np.array(Y_1,dtype='float32')\n",
"_____no_output_____"
],
[
"np.save(\"drive/My Drive/MS_data/train_X.npy\",X_1)\nnp.save(\"drive/My Drive/MS_data/train_Y.npy\",Y_1)",
"_____no_output_____"
],
[
"import numpy as np\n\nX_1=np.load(\"drive/My Drive/MS_data/train_X.npy\")\nY_1=np.load(\"drive/My Drive/MS_data/train_Y.npy\")",
"_____no_output_____"
]
],
[
[
"## creating train test and validation sets",
"_____no_output_____"
]
],
[
[
"extra=[0,1,6,4,6,0,5,0,4,3,1,3,3,0]",
"_____no_output_____"
],
[
"r=np.load(\"drive/My Drive/MS_data/intersection_new_rec_after_removal.npy\")",
"_____no_output_____"
],
[
"rec=list(r)",
"_____no_output_____"
],
[
"j=0\nfinal=[]\nwhile j<len(extra):\n leng=rec[j]+extra[j]\n final.append(leng/8)\n j+=1\n\nnp.save(\"drive/My Drive/MS_data/intersection_final_size.npy\",final)",
"_____no_output_____"
],
[
"r=np.load(\"drive/My Drive/MS_data/intersection_final_size.npy\")",
"_____no_output_____"
],
[
"rec=list(r)",
"_____no_output_____"
],
[
"import json\n\ni=0\nfile_w=\"drive/My Drive/MS_data/per_paitent_records.json\"\nprev=0\ntotal=0\ndict_k={}\nwhile i<len(r):\n current=r[i]\n j=i+1\n dict_k[str(j)]={}\n dict_k[str(j)][\"Starting\"]=prev\n dict_k[str(j)][\"Ending\"]=total+current-1\n total+=current\n prev=total\n i+=1\n\nwith open(file_w, \"w\") as outfile:\n\t\t\tjson.dump(dict_k, outfile) \n",
"_____no_output_____"
],
[
"import random\nimport json\ndict_l={}\nlist_val=[]\nlist_train=[]\nfile_w=\"drive/My Drive/MS_data/set_divisions.json\"\nlist_test=[]\nfor i in range(5):\n patient_list=['1','2','3','4','5','6','7','8','9','10','11','12','13','14']\n for j in range(7):\n flag=0\n while(flag!=1):\n num=random.randint(1,14)\n if patient_list.count(str(num))> 0:\n list_train.append(str(num))\n patient_list.remove(str(num))\n flag=1\n if dict_l.get(\"train\") is None:\n dict_l[\"train\"]=[list_train]\n else:\n dict_l[\"train\"].append(list_train)\n list_train=[]\n for j in range(3):\n flag=0\n while(flag!=1):\n num=random.randint(1,14)\n if patient_list.count(str(num))> 0:\n list_val.append(str(num))\n patient_list.remove(str(num))\n flag=1\n if dict_l.get(\"validate\") is None:\n dict_l[\"validate\"]=[list_val]\n else:\n dict_l[\"validate\"].append(list_val)\n list_val=[]\n for j in range(4):\n flag=0\n while(flag!=1):\n num=random.randint(1,14)\n if patient_list.count(str(num))> 0:\n list_test.append(str(num))\n patient_list.remove(str(num))\n flag=1\n if dict_l.get(\"test\") is None:\n dict_l[\"test\"]=[list_test]\n else:\n dict_l[\"test\"].append(list_test)\n list_test=[] \n\nwith open(file_w, \"w\") as outfile:\n\t\t\tjson.dump(dict_l, outfile) \n\n ",
"_____no_output_____"
],
[
"import pandas as pd\nimport numpy as np\nimport json\nimport os\n\nY=np.load(\"drive/My Drive/MS_data/train_Y.npy\")\nprint(len(Y))\nX=np.load(\"drive/My Drive/MS_data/train_X.npy\")\nprint(len(X))\nf1=open(\"drive/My Drive/MS_data/per_paitent_records.json\")\ndata_1=json.load(f1)\nf2=open(\"drive/My Drive/MS_data/set_divisions.json\")\ndata_2=json.load(f2)\ni=1\nwhile i<=5:\n file_1=\"drive/My Drive/MS_data/\"+str(i)\n print(file_1)\n os.mkdir(file_1)\n train_list=(data_2['train'])[i-1]\n file_1_ext=file_1+'/train'\n print(file_1_ext)\n os.mkdir(file_1_ext)\n X_temp=[]\n Y_temp=[]\n for j in train_list:\n st_index=data_1[str(j)][\"Starting\"]\n end_index=data_1[str(j)][\"Ending\"]\n X_temp.append(X[int(st_index):int(end_index)])\n Y_temp.append(Y[int(st_index):int(end_index)])\n file_1_X=file_1_ext+'/'+'X.npy'\n file_1_Y=file_1_ext+'/'+'Y.npy'\n X_temp_np=np.concatenate((X_temp[0],X_temp[1],X_temp[2],X_temp[3],X_temp[4],X_temp[5],X_temp[6]),axis=0)\n Y_temp_np=np.concatenate((Y_temp[0],Y_temp[1],Y_temp[2],Y_temp[3],Y_temp[4],Y_temp[5],Y_temp[6]),axis=0)\n print(len(X_temp_np))\n print(len(Y_temp_np))\n np.save(file_1_X,X_temp_np)\n np.save(file_1_Y,Y_temp_np)\n train_list=(data_2['validate'])[i-1]\n file_1_ext=file_1+'/validate'\n os.mkdir(file_1_ext)\n X_temp=[]\n Y_temp=[]\n for j in train_list:\n st_index=data_1[str(j)][\"Starting\"]\n end_index=data_1[str(j)][\"Ending\"]\n X_temp.append(X[int(st_index):int(end_index)])\n Y_temp.append(Y[int(st_index):int(end_index)])\n file_1_X=file_1_ext+'/'+'X.npy'\n file_1_Y=file_1_ext+'/'+'Y.npy'\n X_temp_np=np.concatenate((X_temp[0],X_temp[1],X_temp[2]),axis=0)\n Y_temp_np=np.concatenate((Y_temp[0],Y_temp[1],Y_temp[2]),axis=0)\n print(len(X_temp_np))\n print(len(Y_temp_np))\n np.save(file_1_X,X_temp_np)\n np.save(file_1_Y,Y_temp_np)\n train_list=(data_2['test'])[i-1]\n file_1_ext=file_1+'/test'\n os.mkdir(file_1_ext)\n X_temp=[]\n Y_temp=[]\n for j in train_list:\n st_index=data_1[str(j)][\"Starting\"]\n end_index=data_1[str(j)][\"Ending\"]\n X_temp.append(X[int(st_index):int(end_index)])\n Y_temp.append(Y[int(st_index):int(end_index)])\n file_1_X=file_1_ext+'/'+'X.npy'\n file_1_Y=file_1_ext+'/'+'Y.npy'\n X_temp_np=np.concatenate((X_temp[0],X_temp[1],X_temp[2],X_temp[3]),axis=0)\n Y_temp_np=np.concatenate((Y_temp[0],Y_temp[1],Y_temp[2],Y_temp[3]),axis=0)\n print(len(X_temp_np))\n print(len(Y_temp_np))\n np.save(file_1_X,X_temp_np)\n np.save(file_1_Y,Y_temp_np)\n i+=1\n\n",
"372\n372\ndrive/My Drive/MS_data/1\ndrive/My Drive/MS_data/1/train\n198\n198\n76\n76\n84\n84\ndrive/My Drive/MS_data/2\ndrive/My Drive/MS_data/2/train\n201\n201\n60\n60\n97\n97\ndrive/My Drive/MS_data/3\ndrive/My Drive/MS_data/3/train\n182\n182\n51\n51\n125\n125\ndrive/My Drive/MS_data/4\ndrive/My Drive/MS_data/4/train\n179\n179\n89\n89\n90\n90\ndrive/My Drive/MS_data/5\ndrive/My Drive/MS_data/5/train\n157\n157\n78\n78\n123\n123\n"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"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"
]
] |
ece86cca6e6d2e73327141181a1a88dcca87f90c | 552,853 | ipynb | Jupyter Notebook | 1. Load and Visualize Data.ipynb | joeysantana3/udacity-nano-degree | 6fe322d4933f093be2dd48dbedc2326aeb25782b | [
"MIT"
] | null | null | null | 1. Load and Visualize Data.ipynb | joeysantana3/udacity-nano-degree | 6fe322d4933f093be2dd48dbedc2326aeb25782b | [
"MIT"
] | null | null | null | 1. Load and Visualize Data.ipynb | joeysantana3/udacity-nano-degree | 6fe322d4933f093be2dd48dbedc2326aeb25782b | [
"MIT"
] | null | null | null | 845.340979 | 160,488 | 0.948397 | [
[
[
"# Facial Keypoint Detection\n \nThis project will be all about defining and training a convolutional neural network to perform facial keypoint detection and using computer vision techniques to transform images of faces. The first step in any challenge like this will be to load and visualize the data you'll be working with. \n\nLet's take a look at some examples of images and corresponding facial keypoints.\n\n<img src='images/key_pts_example.png' width=50% height=50%/>\n\nFacial keypoints (also called facial landmarks) are the small magenta dots shown on each of the faces in the image above. In each training and test image, there is a single face and **68 keypoints, with coordinates (x, y), for that face**. These keypoints mark important areas of the face: the eyes, corners of the mouth, the nose, etc. These keypoints are relevant for a variety of tasks, such as face filters, emotion recognition, pose recognition, and so on. Here they are, numbered, and you can see that specific ranges of points match different portions of the face.\n\n<img src='images/landmarks_numbered.jpg' width=30% height=30%/>\n\n---",
"_____no_output_____"
],
[
"## Load and Visualize Data\n\nThe first step in working with any dataset is to become familiar with your data; you'll need to load in the images of faces and their keypoints and visualize them! This set of image data has been extracted from the [YouTube Faces Dataset](https://www.cs.tau.ac.il/~wolf/ytfaces/), which includes videos of people in YouTube videos. These videos have been fed through some processing steps and turned into sets of image frames containing one face and the associated keypoints.\n\n#### Training and Testing Data\n\nThis facial keypoints dataset consists of 5770 color images. All of these images are separated into either a training or a test set of data.\n\n* 3462 of these images are training images, for you to use as you create a model to predict keypoints.\n* 2308 are test images, which will be used to test the accuracy of your model.\n\nThe information about the images and keypoints in this dataset are summarized in CSV files, which we can read in using `pandas`. Let's read the training CSV and get the annotations in an (N, 2) array where N is the number of keypoints and 2 is the dimension of the keypoint coordinates (x, y).\n\n---",
"_____no_output_____"
]
],
[
[
"# import the required libraries\nimport glob\nimport os\nimport numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport matplotlib.image as mpimg\n\nimport cv2",
"_____no_output_____"
],
[
"key_pts_frame = pd.read_csv('data/training_frames_keypoints.csv')\n\nn = 0\nimage_name = key_pts_frame.iloc[n, 0]\nkey_pts = key_pts_frame.iloc[n, 1:].as_matrix()\nkey_pts = key_pts.astype('float').reshape(-1, 2)\n\nprint('Image name: ', image_name)\nprint('Landmarks shape: ', key_pts.shape)\nprint('First 4 key pts: {}'.format(key_pts[:4]))",
"_____no_output_____"
],
[
"# print out some stats about the data\nprint('Number of images: ', key_pts_frame.shape[0])",
"_____no_output_____"
]
],
[
[
"## Look at some images\n\nBelow, is a function `show_keypoints` that takes in an image and keypoints and displays them. As you look at this data, **note that these images are not all of the same size**, and neither are the faces! To eventually train a neural network on these images, we'll need to standardize their shape.",
"_____no_output_____"
]
],
[
[
"def show_keypoints(image, key_pts):\n \"\"\"Show image with keypoints\"\"\"\n plt.imshow(image)\n plt.scatter(key_pts[:, 0], key_pts[:, 1], s=20, marker='.', c='m')\n",
"_____no_output_____"
],
[
"# Display a few different types of images by changing the index n\n\n# select an image by index in our data frame\nn = 0\nimage_name = key_pts_frame.iloc[n, 0]\nkey_pts = key_pts_frame.iloc[n, 1:].values\nkey_pts = key_pts.astype('float').reshape(-1, 2)\n\nplt.figure(figsize=(5, 5))\nshow_keypoints(mpimg.imread(os.path.join('data/training/', image_name)), key_pts)\nplt.show()",
"_____no_output_____"
]
],
[
[
"## Dataset class and Transformations\n\nTo prepare our data for training, we'll be using PyTorch's Dataset class. Much of this this code is a modified version of what can be found in the [PyTorch data loading tutorial](http://pytorch.org/tutorials/beginner/data_loading_tutorial.html).\n\n#### Dataset class\n\n``torch.utils.data.Dataset`` is an abstract class representing a\ndataset. This class will allow us to load batches of image/keypoint data, and uniformly apply transformations to our data, such as rescaling and normalizing images for training a neural network.\n\n\nYour custom dataset should inherit ``Dataset`` and override the following\nmethods:\n\n- ``__len__`` so that ``len(dataset)`` returns the size of the dataset.\n- ``__getitem__`` to support the indexing such that ``dataset[i]`` can\n be used to get the i-th sample of image/keypoint data.\n\nLet's create a dataset class for our face keypoints dataset. We will\nread the CSV file in ``__init__`` but leave the reading of images to\n``__getitem__``. This is memory efficient because all the images are not\nstored in the memory at once but read as required.\n\nA sample of our dataset will be a dictionary\n``{'image': image, 'keypoints': key_pts}``. Our dataset will take an\noptional argument ``transform`` so that any required processing can be\napplied on the sample. We will see the usefulness of ``transform`` in the\nnext section.\n",
"_____no_output_____"
]
],
[
[
"from torch.utils.data import Dataset, DataLoader\n\nclass FacialKeypointsDataset(Dataset):\n \"\"\"Face Landmarks dataset.\"\"\"\n\n def __init__(self, csv_file, root_dir, transform=None):\n \"\"\"\n Args:\n csv_file (string): Path to the csv file with annotations.\n root_dir (string): Directory with all the images.\n transform (callable, optional): Optional transform to be applied\n on a sample.\n \"\"\"\n self.key_pts_frame = pd.read_csv(csv_file)\n self.root_dir = root_dir\n self.transform = transform\n\n def __len__(self):\n return len(self.key_pts_frame)\n\n def __getitem__(self, idx):\n image_name = os.path.join(self.root_dir,\n self.key_pts_frame.iloc[idx, 0])\n \n image = mpimg.imread(image_name)\n \n # if image has an alpha color channel, get rid of it\n if(image.shape[2] == 4):\n image = image[:,:,0:3]\n \n key_pts = self.key_pts_frame.iloc[idx, 1:].values\n key_pts = key_pts.astype('float').reshape(-1, 2)\n sample = {'image': image, 'keypoints': key_pts}\n\n if self.transform:\n sample = self.transform(sample)\n\n return sample",
"_____no_output_____"
]
],
[
[
"Now that we've defined this class, let's instantiate the dataset and display some images.",
"_____no_output_____"
]
],
[
[
"# Construct the dataset\nface_dataset = FacialKeypointsDataset(csv_file='data/training_frames_keypoints.csv',\n root_dir='data/training/')\n\n# print some stats about the dataset\nprint('Length of dataset: ', len(face_dataset))",
"Length of dataset: 3462\n"
],
[
"# Display a few of the images from the dataset\nnum_to_display = 3\n\nfor i in range(num_to_display):\n \n # define the size of images\n fig = plt.figure(figsize=(20,10))\n \n # randomly select a sample\n rand_i = np.random.randint(0, len(face_dataset))\n sample = face_dataset[rand_i]\n\n # print the shape of the image and keypoints\n print(i, sample['image'].shape, sample['keypoints'].shape)\n\n ax = plt.subplot(1, num_to_display, i + 1)\n ax.set_title('Sample #{}'.format(i))\n \n # Using the same display function, defined earlier\n show_keypoints(sample['image'], sample['keypoints'])\n",
"0 (187, 164, 3) (68, 2)\n1 (169, 211, 3) (68, 2)\n2 (123, 101, 3) (68, 2)\n"
]
],
[
[
"## Transforms\n\nNow, the images above are not of the same size, and neural networks often expect images that are standardized; a fixed size, with a normalized range for color ranges and coordinates, and (for PyTorch) converted from numpy lists and arrays to Tensors.\n\nTherefore, we will need to write some pre-processing code.\nLet's create four transforms:\n\n- ``Normalize``: to convert a color image to grayscale values with a range of [0,1] and normalize the keypoints to be in a range of about [-1, 1]\n- ``Rescale``: to rescale an image to a desired size.\n- ``RandomCrop``: to crop an image randomly.\n- ``ToTensor``: to convert numpy images to torch images.\n\n\nWe will write them as callable classes instead of simple functions so\nthat parameters of the transform need not be passed every time it's\ncalled. For this, we just need to implement ``__call__`` method and \n(if we require parameters to be passed in), the ``__init__`` method. \nWe can then use a transform like this:\n\n tx = Transform(params)\n transformed_sample = tx(sample)\n\nObserve below how these transforms are generally applied to both the image and its keypoints.\n\n",
"_____no_output_____"
]
],
[
[
"import torch\nfrom torchvision import transforms, utils\n# tranforms\n\nclass Normalize(object):\n \"\"\"Convert a color image to grayscale and normalize the color range to [0,1].\"\"\" \n\n def __call__(self, sample):\n image, key_pts = sample['image'], sample['keypoints']\n \n image_copy = np.copy(image)\n key_pts_copy = np.copy(key_pts)\n\n # convert image to grayscale\n image_copy = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)\n \n # scale color range from [0, 255] to [0, 1]\n image_copy= image_copy/255.0\n \n # scale keypoints to be centered around 0 with a range of [-1, 1]\n # mean = 100, sqrt = 50, so, pts should be (pts - 100)/50\n key_pts_copy = (key_pts_copy - 100)/50.0\n\n\n return {'image': image_copy, 'keypoints': key_pts_copy}\n\n\nclass Rescale(object):\n \"\"\"Rescale the image in a sample to a given size.\n\n Args:\n output_size (tuple or int): Desired output size. If tuple, output is\n matched to output_size. If int, smaller of image edges is matched\n to output_size keeping aspect ratio the same.\n \"\"\"\n\n def __init__(self, output_size):\n assert isinstance(output_size, (int, tuple))\n self.output_size = output_size\n\n def __call__(self, sample):\n image, key_pts = sample['image'], sample['keypoints']\n\n h, w = image.shape[:2]\n if isinstance(self.output_size, int):\n if h > w:\n new_h, new_w = self.output_size * h / w, self.output_size\n else:\n new_h, new_w = self.output_size, self.output_size * w / h\n else:\n new_h, new_w = self.output_size\n\n new_h, new_w = int(new_h), int(new_w)\n\n img = cv2.resize(image, (new_w, new_h))\n \n # scale the pts, too\n key_pts = key_pts * [new_w / w, new_h / h]\n\n return {'image': img, 'keypoints': key_pts}\n\n\nclass RandomCrop(object):\n \"\"\"Crop randomly the image in a sample.\n\n Args:\n output_size (tuple or int): Desired output size. If int, square crop\n is made.\n \"\"\"\n\n def __init__(self, output_size):\n assert isinstance(output_size, (int, tuple))\n if isinstance(output_size, int):\n self.output_size = (output_size, output_size)\n else:\n assert len(output_size) == 2\n self.output_size = output_size\n\n def __call__(self, sample):\n image, key_pts = sample['image'], sample['keypoints']\n\n h, w = image.shape[:2]\n new_h, new_w = self.output_size\n\n top = np.random.randint(0, h - new_h)\n left = np.random.randint(0, w - new_w)\n\n image = image[top: top + new_h,\n left: left + new_w]\n\n key_pts = key_pts - [left, top]\n\n return {'image': image, 'keypoints': key_pts}\n\n\nclass ToTensor(object):\n \"\"\"Convert ndarrays in sample to Tensors.\"\"\"\n\n def __call__(self, sample):\n image, key_pts = sample['image'], sample['keypoints']\n \n # if image has no grayscale color channel, add one\n if(len(image.shape) == 2):\n # add that third color dim\n image = image.reshape(image.shape[0], image.shape[1], 1)\n \n # swap color axis because\n # numpy image: H x W x C\n # torch image: C X H X W\n image = image.transpose((2, 0, 1))\n \n return {'image': torch.from_numpy(image),\n 'keypoints': torch.from_numpy(key_pts)}",
"_____no_output_____"
]
],
[
[
"## Test out the transforms\n\nLet's test these transforms out to make sure they behave as expected. As you look at each transform, note that, in this case, **order does matter**. For example, you cannot crop an image using a value smaller than the original image (and the orginal images vary in size!), but, if you first rescale the original image, you can then crop it to any size smaller than the rescaled size.",
"_____no_output_____"
]
],
[
[
"# test out some of these transforms\nrescale = Rescale(100)\ncrop = RandomCrop(50)\ncomposed = transforms.Compose([Rescale(250),\n RandomCrop(224)])\n\n# apply the transforms to a sample image\ntest_num = 400\nsample = face_dataset[test_num]\n\nfig = plt.figure()\nfor i, tx in enumerate([rescale, crop, composed]):\n transformed_sample = tx(sample)\n\n ax = plt.subplot(1, 3, i + 1)\n plt.tight_layout()\n ax.set_title(type(tx).__name__)\n show_keypoints(transformed_sample['image'], transformed_sample['keypoints'])\n\nplt.show()",
"_____no_output_____"
]
],
[
[
"## Create the transformed dataset\n\nApply the transforms in order to get grayscale images of the same shape. Verify that your transform works by printing out the shape of the resulting data (printing out a few examples should show you a consistent tensor size).",
"_____no_output_____"
]
],
[
[
"# define the data tranform\n# order matters! i.e. rescaling should come before a smaller crop\ndata_transform = transforms.Compose([Rescale(250),\n RandomCrop(224),\n Normalize(),\n ToTensor()])\n\n# create the transformed dataset\ntransformed_dataset = FacialKeypointsDataset(csv_file='data/training_frames_keypoints.csv',\n root_dir='data/training/',\n transform=data_transform)\n",
"_____no_output_____"
],
[
"# print some stats about the transformed data\nprint('Number of images: ', len(transformed_dataset))\n\n# make sure the sample tensors are the expected size\nfor i in range(5):\n sample = transformed_dataset[i]\n print(i, sample['image'].size(), sample['keypoints'].size())\n",
"Number of images: 3462\n0 torch.Size([1, 224, 224]) torch.Size([68, 2])\n1 torch.Size([1, 224, 224]) torch.Size([68, 2])\n2 torch.Size([1, 224, 224]) torch.Size([68, 2])\n3 torch.Size([1, 224, 224]) torch.Size([68, 2])\n4 torch.Size([1, 224, 224]) torch.Size([68, 2])\n"
]
],
[
[
"## Data Iteration and Batching\n\nRight now, we are iterating over this data using a ``for`` loop, but we are missing out on a lot of PyTorch's dataset capabilities, specifically the abilities to:\n\n- Batch the data\n- Shuffle the data\n- Load the data in parallel using ``multiprocessing`` workers.\n\n``torch.utils.data.DataLoader`` is an iterator which provides all these\nfeatures, and we'll see this in use in the *next* notebook, Notebook 2, when we load data in batches to train a neural network!\n\n---\n\n",
"_____no_output_____"
],
[
"## Ready to Train!\n\nNow that you've seen how to load and transform our data, you're ready to build a neural network to train on this data.\n\nIn the next notebook, you'll be tasked with creating a CNN for facial keypoint detection.",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
]
] |
ece875388faa615033008ec80227fb389f8f5531 | 68,272 | ipynb | Jupyter Notebook | notebooks/generate_observations.ipynb | natbolon/weather_prediction | f3a18264e5e642cf366e7d181e6e081ab7f21eab | [
"MIT"
] | 2 | 2020-07-22T15:07:25.000Z | 2020-09-22T12:32:51.000Z | notebooks/generate_observations.ipynb | natbolon/weather_prediction | f3a18264e5e642cf366e7d181e6e081ab7f21eab | [
"MIT"
] | null | null | null | notebooks/generate_observations.ipynb | natbolon/weather_prediction | f3a18264e5e642cf366e7d181e6e081ab7f21eab | [
"MIT"
] | 2 | 2020-09-27T20:20:03.000Z | 2021-01-15T12:15:21.000Z | 48.248763 | 4,193 | 0.512992 | [
[
[
"## Generate data ",
"_____no_output_____"
]
],
[
[
"import sys\nsys.path.append('/'.join(sys.path[0].split('/')[:-1]))\n\nimport os\nimport xarray as xr\nimport numpy as np\nimport time\nimport matplotlib.pyplot as plt\nimport healpy as hp\n\nimport torch\nfrom torch import nn, optim\nfrom torch.utils.data import Dataset, DataLoader\n",
"_____no_output_____"
],
[
"datadir = \"../data/healpix/5.625deg_nearest/\"\n\nlr=1e-4\ndr=0\nbatch_size=128\npatience=3\ntrain_years=('1979', '2015')\nvalid_years=('2016', '2016')\ntest_years=('2017', '2018')\ngpu=1\niterative=False\n\nvars = ['z', 't']\nkernel_size = 5",
"_____no_output_____"
],
[
"z = xr.open_mfdataset(f'{datadir}geopotential_500/*.nc', combine='by_coords')\nt = xr.open_mfdataset(f'{datadir}temperature_850/*.nc', combine='by_coords')\nds = xr.merge([z, t], compat='override')",
"_____no_output_____"
],
[
"def create_iterative_observations_healpix(ds, lead_time, max_lead_time, nb_timesteps, test_years, nodes):\n \n lead_times = np.arange(lead_time, max_lead_time + lead_time, lead_time)\n\n data = ds.to_array(dim='level', name='Dataset').transpose('time', 'node', 'level')\n n_samples = data.isel(time=slice(0, -nb_timesteps*lead_time)).shape[0] - max_lead_time\n\n obs_list = []\n \n print('Generating observations list...')\n for lead in lead_times:\n obs_list.append(data.isel(time=slice(lead, lead + n_samples)).isel(level=slice(0, 2)))\n\n #observations_numpy = np.array(obs_list)\n observations_joint = xr.concat(obs_list, dim='lead_time')\n #return observations_numpy\n print('Obtaining coordinates...')\n # Lat lon coordinates\n nside = int(np.sqrt(nodes/12))\n out_lon, out_lat = hp.pix2ang(nside, np.arange(nodes), lonlat=True)\n \n print('Generate set of times to study', end='\\n')\n # Actual times\n start = np.datetime64(test_years[0], 'h') + np.timedelta64(lead_time, 'h')\n stop = start + np.timedelta64(n_samples, 'h')\n times = np.arange(start, stop)\n\n # Variables\n var_dict_out = {var: None for var in ['z', 't']}\n\n das = [];\n lev_idx = 0\n \n for var, levels in var_dict_out.items():\n das.append(observations_joint.isel(level=lev_idx).rename(var))\n lev_idx +=1\n \n \"\"\"\n \n \n if levels is None: \n das.append(xr.DataArray(\n observations_numpy[:, :, :, lev_idx],\n dims=['lead_time', 'time', 'node'],\n coords={'lead_time': lead_times, 'time': times, 'node': np.arange(nodes)},\n name=var\n ))\n lev_idx += 1\n # never this case...\n else:\n nlevs = len(levels)\n das.append(xr.DataArray(\n observations_numpy[:, :, :, lev_idx:lev_idx+nlevs],\n dims=['lead_time', 'time', 'node', 'level'],\n coords={'lead_time': lead_times, 'time': valid_time, 'node': nodes, 'level': nlevs},\n name=var\n ))\n lev_idx += nlevs\n \"\"\"\n \n print('\\nGenerate observation...')\n observation_ds = xr.merge(das, compat='override').reset_coords(names='level', drop=True)\n observation_ds = observation_ds.assign_coords({'lat': out_lat, 'lon': out_lon})\n return observation_ds\n",
"_____no_output_____"
],
[
"nodes = 12*16*16\nmax_lead_time = 5*24\nlead_time = 6\nout_features = 2\nnb_timesteps = 2\nnside = int(np.sqrt(nodes/12))",
"_____no_output_____"
],
[
"#obs = create_iterative_observations_hp(\"../data/equiangular/5.625deg/\", test_years, lead_time, max_lead_time, nside, nb_timesteps=2)",
"_____no_output_____"
],
[
"obs = create_iterative_observations_healpix(ds, lead_time, max_lead_time, nb_timesteps, test_years, nodes)",
"Generating observations list...\nObtaining coordinates...\nGenerate set of times to study\n\nGenerate observation...\n"
],
[
"obs",
"_____no_output_____"
],
[
"obs.to_netcdf(datadir + 'observations.nc')",
"_____no_output_____"
]
],
[
[
"### Use new functions from Iciar",
"_____no_output_____"
]
],
[
[
"from modules.test import create_iterative_observations_hp",
"_____no_output_____"
],
[
"nodes = 12*16*16\nmax_lead_time = 5*24\nlead_time = 6\nout_features = 2\nnb_timesteps = 2\nnside = int(np.sqrt(nodes/12))",
"_____no_output_____"
],
[
"def create_iterative_observations_hp(input_dir, test_years, lead_time, max_lead_time, nside, nb_timesteps=2):\n z500 = xr.open_mfdataset(f'{input_dir}geopotential_500/*.nc', combine='by_coords').sel(time=slice(*test_years))\n t850 = xr.open_mfdataset(f'{input_dir}temperature_850/*.nc', combine='by_coords').sel(time=slice(*test_years))\n\n test_data = xr.merge([z500, t850], compat='override')\n\n\n n_samples = test_data.isel(time=slice(0, -nb_timesteps*lead_time)).dims['time'] - max_lead_time\n nb_iter = max_lead_time // lead_time\n n_pixels = 12*(nside**2)\n print(n_samples)\n\n # Lead times\n lead_times = np.arange(lead_time, max_lead_time + lead_time, lead_time)\n\n # Lat lon coordinates\n out_lon, out_lat = hp.pix2ang(nside, np.arange(n_pixels), lonlat=True)\n\n # Actual times\n start = np.datetime64(test_years[0], 'h') + np.timedelta64(lead_time, 'h')\n stop = start + np.timedelta64(n_samples, 'h')\n times = np.arange(start, stop, 1)\n\n # Variables\n data_vars = ['z', 't']\n var_dict_out = {var: None for var in data_vars}\n \n data = np.zeros((2, nb_iter, n_samples, 3072))\n \n #data = np.zeros((2, nb_iter, n_samples, 32, 64))\n for i in range(nb_iter):\n #data[0, i, :, :, :] = test_data.z.isel(time=slice(lead_time*(i+1), lead_time*(i+1) + n_samples)).values\n #data[1, i, :, :, :] = test_data.t.isel(time=slice(lead_time*(i+1), lead_time*(i+1) + n_samples)).values\n \n data[0, i, :, :] = test_data.z.isel(time=slice(lead_time*(i+1), lead_time*(i+1) + n_samples)).values\n data[1, i, :, :] = test_data.t.isel(time=slice(lead_time*(i+1), lead_time*(i+1) + n_samples)).values\n\n\n das = [];\n lev_idx = 0\n for var in data_vars: \n das.append(xr.DataArray(\n data[lev_idx, :, :, :],\n dims=['lead_time', 'time', 'node'],\n coords={'lead_time': lead_times, 'time': times, 'node': np.arange(n_pixels)},\n name=var\n ))\n lev_idx += 1\n observations = xr.merge(das)\n #observations = observations.assign_coords({'lat': out_lat, 'lon': out_lon})\n\n return observations",
"_____no_output_____"
],
[
"observations = create_iterative_observations_hp('../data/healpix/5.625deg_nearest/', test_years, lead_time, max_lead_time, nside, nb_timesteps=2)",
"17388\n"
],
[
"observations",
"_____no_output_____"
],
[
"n_pixels = 12*(nside**2)\nout_lon, out_lat = hp.pix2ang(nside, np.arange(n_pixels), lonlat=True)",
"_____no_output_____"
],
[
"observations = observations.assign_coords({'lat': ('node', out_lat), 'lon': ('node', out_lon)})",
"_____no_output_____"
],
[
"observations.to_netcdf('../data/healpix/predictions/' + 'observations_nearest.nc')",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ece8775709d66e5c0dc6a822c43e3eb3c3346e96 | 5,044 | ipynb | Jupyter Notebook | src/20grid_random_walk_01.ipynb | songqsh/Computational-finance | 8314838e1486c3b894726bef214f8e7694e76059 | [
"MIT"
] | 2 | 2020-02-07T23:11:44.000Z | 2020-02-08T14:39:45.000Z | src/Lecture notes/20grid_random_walk_01.ipynb | JiaminJIAN/20MA573 | a9bc42a769b112c9beb9b1fcafb742a768a2a18e | [
"MIT"
] | null | null | null | src/Lecture notes/20grid_random_walk_01.ipynb | JiaminJIAN/20MA573 | a9bc42a769b112c9beb9b1fcafb742a768a2a18e | [
"MIT"
] | 8 | 2020-01-21T08:39:31.000Z | 2020-09-16T00:44:16.000Z | 25.474747 | 421 | 0.45797 | [
[
[
"# Escaping from a Gridworld \n\nWe will take n dimensional gridworld of any shape as our experimental environment. Read and understand the code in the following shell. Then proceed to next questions.",
"_____no_output_____"
]
],
[
[
"import random\n\nclass grid:\n def __init__(self, shape = (5, 5)):\n self.n_dim = len(shape)\n self.shape = shape\n print('>>> grid world shape is: '+str(shape))\n\n def is_interior(self,ix):\n return all([0.<a<b-1 for a,b in zip(ix,list(self.shape))])\n \n #input: lists of index\n #return: running cost, list of next index, list of probability\n def step(self, ix):\n run_cost = 0. \n ix_next = []; pr_next= []\n if self.is_interior(ix):\n run_cost = 1.\n for i in range(self.n_dim):\n ix1 = ix.copy(); ix1[i]+=1; ix_next += [ix1,]\n pr1 = 1./(self.n_dim*2.0) \n pr_next += [pr1,]\n for i in range(self.n_dim):\n ix1 = ix.copy(); ix1[i]-=1; ix_next += [ix1,]\n pr1 = 1./(self.n_dim*2.0) \n pr_next += [pr1,]\n \n return run_cost, ix_next, pr_next\n \n def step_random(self, ix):\n run_cost, ix_next, pr_next = self.step(ix)\n ix_next_rd = random.choices(ix_next, pr_next, k = 1)\n return run_cost, ix_next_rd[0]\n",
"_____no_output_____"
]
],
[
[
"- Explain the meaning of each output from the next shell\n- (Your answer)\n",
"_____no_output_____"
]
],
[
[
"\n#####check\ng1 = grid(shape=(5,5))\nix1 = [2,3]\nprint('>>>', g1.is_interior(ix1))\no1, o2, o3 = g1.step(ix1)\nprint('>>>', o1, '\\n', o2, '\\n', o3)\n\nprint('>>>>>>>>><<<<<<<<<<')\nix2 = [1,4]\nprint('>>>', g1.is_interior(ix2))\no1, o2, o3 = g1.step(ix2)\nprint('>>>', o1, '\\n', o2, '\\n', o3)\n",
">>> grid world shape is: (5, 5)\n>>> True\n>>> 1.0 \n [[3, 3], [2, 4], [1, 3], [2, 2]] \n [0.25, 0.25, 0.25, 0.25]\n>>>>>>>>><<<<<<<<<<\n>>> False\n>>> 0.0 \n [] \n []\n"
]
],
[
[
"- Explain the meaning of each output from the next shell\n- (Your answer)",
"_____no_output_____"
]
],
[
[
"#import ipdb\n\nix = [2,2]\ntot_cost = 0.\nwhile g1.is_interior(ix):\n #ipdb.set_trace()\n run_cost, ix = g1.step_random(ix)\n print('>>>', ix)\n tot_cost+=run_cost\n \nprint('>>>', tot_cost)",
">>> [1, 2]\n>>> [1, 3]\n>>> [1, 4]\n>>> 3.0\n"
]
],
[
[
"- Consider a grid world of shape (4,4). This means, the agent's state belongs to the state space of $\\{0,1,2,3,4\\}\\times \\{0,1,2,3,4\\}$. A state $(a,b)$ is called a boundary if one of its coordinate is either $0$ or $4$. Otherwise, the state is called interior. An agent moves a random walk in the grid world from initial state $(2,2)$. Use your math to find the expected number of steps to reach the boundary.",
"_____no_output_____"
],
[
"- (your answer)",
"_____no_output_____"
],
[
"- Use your code to verify your answer.",
"_____no_output_____"
]
],
[
[
"#your code \npass",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
]
] |
ece8811b32d5d11097757442db9d95a3e2a2655c | 50,981 | ipynb | Jupyter Notebook | src/model/pytorch/21-RL/DeepRL-Tutorials/08.Rainbow.ipynb | inessus/ai-skills | 527f32d49887f06eee357c83bb6a9a21edc69bc5 | [
"MIT"
] | 5 | 2018-10-30T01:36:04.000Z | 2020-11-26T02:38:09.000Z | src/model/pytorch/21-RL/DeepRL-Tutorials/08.Rainbow.ipynb | inessus/ai-skills | 527f32d49887f06eee357c83bb6a9a21edc69bc5 | [
"MIT"
] | 4 | 2020-11-18T21:34:06.000Z | 2022-03-11T23:32:44.000Z | src/model/pytorch/21-RL/DeepRL-Tutorials/08.Rainbow.ipynb | inessus/ai-skills | 527f32d49887f06eee357c83bb6a9a21edc69bc5 | [
"MIT"
] | 1 | 2018-11-27T09:19:38.000Z | 2018-11-27T09:19:38.000Z | 140.057692 | 38,724 | 0.864067 | [
[
[
"# Rainbow: Combining Improvements in Deep Reinforcement Learning",
"_____no_output_____"
],
[
"## Imports",
"_____no_output_____"
]
],
[
[
"import gym\nimport numpy as np\n\nimport torch\nimport torch.optim as optim\nimport torch.nn as nn\nimport torch.nn.functional as F\n\nfrom IPython.display import clear_output\nfrom matplotlib import pyplot as plt\n%matplotlib inline\n\nfrom timeit import default_timer as timer\nfrom datetime import timedelta\nimport math\n\nfrom utils.wrappers import *\nfrom utils.ReplayMemory import PrioritizedReplayMemory\nfrom networks.layers import NoisyLinear\nfrom agents.DQN import Model as DQN_Agent\n\nfrom utils.hyperparameters import Config",
"_____no_output_____"
]
],
[
[
"## Hyperparameters",
"_____no_output_____"
]
],
[
[
"config = Config()\n\nconfig.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n#Multi-step returns\nconfig.N_STEPS = 3\n\n#misc agent variables\nconfig.GAMMA=0.99\nconfig.LR=1e-4\n\n#memory\nconfig.TARGET_NET_UPDATE_FREQ = 1000\nconfig.EXP_REPLAY_SIZE = 100000\nconfig.BATCH_SIZE = 32\nconfig.PRIORITY_ALPHA=0.6\nconfig.PRIORITY_BETA_START=0.4\nconfig.PRIORITY_BETA_FRAMES = 100000\n\n#epsilon variables\nconfig.SIGMA_INIT=0.5\n\n#Learning control variables\nconfig.LEARN_START = 10000\nconfig.MAX_FRAMES=700000\n\n#Categorical Params\nconfig.ATOMS = 51\nconfig.V_MAX = 10\nconfig.V_MIN = -10",
"_____no_output_____"
]
],
[
[
"## Network",
"_____no_output_____"
]
],
[
[
"class CategoricalDuelingDQN(nn.Module):\n def __init__(self, input_shape, num_actions, sigma_init=0.5, atoms=51):\n super(CategoricalDuelingDQN, self).__init__()\n \n self.input_shape = input_shape\n self.num_actions = num_actions\n self.atoms = atoms\n\n self.conv1 = nn.Conv2d(self.input_shape[0], 32, kernel_size=8, stride=4)\n self.conv2 = nn.Conv2d(32, 64, kernel_size=4, stride=2)\n self.conv3 = nn.Conv2d(64, 64, kernel_size=3, stride=1)\n\n self.adv1 = NoisyLinear(self.feature_size(), 512, sigma_init)\n self.adv2 = NoisyLinear(512, self.num_actions*self.atoms, sigma_init)\n\n self.val1 = NoisyLinear(self.feature_size(), 512, sigma_init)\n self.val2 = NoisyLinear(512, 1*self.atoms, sigma_init)\n \n def forward(self, x):\n x = F.relu(self.conv1(x))\n x = F.relu(self.conv2(x))\n x = F.relu(self.conv3(x))\n x = x.view(x.size(0), -1)\n adv = F.relu(self.adv1(x))\n adv = self.adv2(adv).view(-1, self.num_actions, self.atoms)\n\n val = F.relu(self.val1(x))\n val = self.val2(val).view(-1, 1, self.atoms)\n\n final = val + adv - adv.mean(dim=1).view(-1, 1, self.atoms)\n\n return F.softmax(final, dim=2)\n \n def feature_size(self):\n return self.conv3(self.conv2(self.conv1(torch.zeros(1, *self.input_shape)))).view(1, -1).size(1)\n\n def sample_noise(self):\n self.adv1.sample_noise()\n self.adv2.sample_noise()\n self.val1.sample_noise()\n self.val2.sample_noise()",
"_____no_output_____"
]
],
[
[
"## Agent",
"_____no_output_____"
]
],
[
[
"class Model(DQN_Agent):\n def __init__(self, static_policy=False, env=None, config=None):\n self.atoms=config.ATOMS\n self.v_max=config.V_MAX\n self.v_min=config.V_MIN\n self.supports = torch.linspace(self.v_min, self.v_max, self.atoms).view(1, 1, self.atoms).to(config.device)\n self.delta = (self.v_max - self.v_min) / (self.atoms - 1)\n\n super(Model, self).__init__(static_policy, env, config)\n\n self.nsteps=max(self.nsteps,3)\n \n def declare_networks(self):\n self.model = CategoricalDuelingDQN(self.num_feats, self.num_actions, sigma_init=self.sigma_init, atoms=self.atoms)\n self.target_model = CategoricalDuelingDQN(self.num_feats, self.num_actions, sigma_init=self.sigma_init, atoms=self.atoms)\n \n def declare_memory(self):\n self.memory = PrioritizedReplayMemory(self.experience_replay_size, self.priority_alpha, self.priority_beta_start, self.priority_beta_frames)\n \n def projection_distribution(self, batch_vars):\n batch_state, batch_action, batch_reward, non_final_next_states, non_final_mask, empty_next_state_values, indices, weights = batch_vars\n\n with torch.no_grad():\n max_next_dist = torch.zeros((self.batch_size, 1, self.atoms), device=self.device, dtype=torch.float) + 1./self.atoms\n if not empty_next_state_values:\n max_next_action = self.get_max_next_state_action(non_final_next_states)\n self.target_model.sample_noise()\n max_next_dist[non_final_mask] = self.target_model(non_final_next_states).gather(1, max_next_action)\n max_next_dist = max_next_dist.squeeze()\n\n\n Tz = batch_reward.view(-1, 1) + (self.gamma**self.nsteps)*self.supports.view(1, -1) * non_final_mask.to(torch.float).view(-1, 1)\n Tz = Tz.clamp(self.v_min, self.v_max)\n b = (Tz - self.v_min) / self.delta\n l = b.floor().to(torch.int64)\n u = b.ceil().to(torch.int64)\n l[(u > 0) * (l == u)] -= 1\n u[(l < (self.atoms - 1)) * (l == u)] += 1\n \n\n offset = torch.linspace(0, (self.batch_size - 1) * self.atoms, self.batch_size).unsqueeze(dim=1).expand(self.batch_size, self.atoms).to(batch_action)\n m = batch_state.new_zeros(self.batch_size, self.atoms)\n m.view(-1).index_add_(0, (l + offset).view(-1), (max_next_dist * (u.float() - b)).view(-1)) # m_l = m_l + p(s_t+n, a*)(u - b)\n m.view(-1).index_add_(0, (u + offset).view(-1), (max_next_dist * (b - l.float())).view(-1)) # m_u = m_u + p(s_t+n, a*)(b - l)\n\n return m\n \n def compute_loss(self, batch_vars):\n batch_state, batch_action, batch_reward, non_final_next_states, non_final_mask, empty_next_state_values, indices, weights = batch_vars\n\n batch_action = batch_action.unsqueeze(dim=-1).expand(-1, -1, self.atoms)\n batch_reward = batch_reward.view(-1, 1, 1)\n\n #estimate\n self.model.sample_noise()\n current_dist = self.model(batch_state).gather(1, batch_action).squeeze()\n\n target_prob = self.projection_distribution(batch_vars)\n \n loss = -(target_prob * current_dist.log()).sum(-1)\n self.memory.update_priorities(indices, loss.detach().squeeze().abs().cpu().numpy().tolist())\n loss = loss * weights\n loss = loss.mean()\n\n return loss\n \n def get_action(self, s):\n with torch.no_grad():\n X = torch.tensor([s], device=self.device, dtype=torch.float)\n self.model.sample_noise()\n a = self.model(X) * self.supports\n a = a.sum(dim=2).max(1)[1].view(1, 1)\n return a.item()\n \n def get_max_next_state_action(self, next_states):\n next_dist = self.model(next_states) * self.supports\n return next_dist.sum(dim=2).max(1)[1].view(next_states.size(0), 1, 1).expand(-1, -1, self.atoms)",
"_____no_output_____"
]
],
[
[
"## Plot Results",
"_____no_output_____"
]
],
[
[
"def plot(frame_idx, rewards, losses, sigma, elapsed_time):\n clear_output(True)\n plt.figure(figsize=(20,5))\n plt.subplot(131)\n plt.title('frame %s. reward: %s. time: %s' % (frame_idx, np.mean(rewards[-10:]), elapsed_time))\n plt.plot(rewards)\n if losses:\n plt.subplot(132)\n plt.title('loss')\n plt.plot(losses)\n if sigma:\n plt.subplot(133)\n plt.title('noisy param magnitude')\n plt.plot(sigma)\n plt.show()",
"_____no_output_____"
]
],
[
[
"## Training Loop",
"_____no_output_____"
]
],
[
[
"start=timer()\n\nenv_id = \"PongNoFrameskip-v4\"\nenv = make_atari(env_id)\nenv = wrap_deepmind(env, frame_stack=False)\nenv = wrap_pytorch(env)\nmodel = Model(env=env, config=config)\n\nepisode_reward = 0\n\nobservation = env.reset()\nfor frame_idx in range(1, config.MAX_FRAMES + 1):\n action = model.get_action(observation)\n prev_observation=observation\n observation, reward, done, _ = env.step(action)\n observation = None if done else observation\n\n model.update(prev_observation, action, reward, observation, frame_idx)\n episode_reward += reward\n\n if done:\n model.finish_nstep()\n model.reset_hx()\n observation = env.reset()\n model.save_reward(episode_reward)\n episode_reward = 0\n \n if np.mean(model.rewards[-10:]) > 19:\n plot(frame_idx, all_rewards, losses, timedelta(seconds=int(timer()-start)))\n break\n\n if frame_idx % 10000 == 0:\n plot(frame_idx, model.rewards, model.losses, model.sigma_parameter_mag, timedelta(seconds=int(timer()-start)))\n\nmodel.save_w()\nenv.close()",
"_____no_output_____"
]
]
] | [
"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"
]
] |
ece8976b5c46532e228d496587cd047b139c0148 | 941,110 | ipynb | Jupyter Notebook | tensorflow_probability/examples/jupyter_notebooks/Gaussian_Copula.ipynb | Tensorflow-Devs/probability | 719eafd6a052d774b364e47e5a2142e486c33231 | [
"Apache-2.0"
] | 3,670 | 2018-02-14T03:29:40.000Z | 2022-03-30T01:19:52.000Z | tensorflow_probability/examples/jupyter_notebooks/Gaussian_Copula.ipynb | emilyfertig/probability | bb15d65fafb9311475878f518a328c8f9bdcf31e | [
"Apache-2.0"
] | 1,395 | 2018-02-24T02:28:49.000Z | 2022-03-31T16:12:06.000Z | tensorflow_probability/examples/jupyter_notebooks/Gaussian_Copula.ipynb | emilyfertig/probability | bb15d65fafb9311475878f518a328c8f9bdcf31e | [
"Apache-2.0"
] | 1,135 | 2018-02-14T01:51:10.000Z | 2022-03-28T02:24:11.000Z | 1,893.581489 | 231,460 | 0.947479 | [
[
[
"##### Copyright 2018 The TensorFlow Probability Authors.\n\nLicensed under the Apache License, Version 2.0 (the \"License\");",
"_____no_output_____"
]
],
[
[
"#@title Licensed under the Apache License, Version 2.0 (the \"License\"); { display-mode: \"form\" }\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_____"
]
],
[
[
"# Copulas Primer\n\n<table class=\"tfo-notebook-buttons\" align=\"left\">\n <td>\n <a target=\"_blank\" href=\"https://www.tensorflow.org/probability/examples/Gaussian_Copula\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />View on TensorFlow.org</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/probability/blob/main/tensorflow_probability/examples/jupyter_notebooks/Gaussian_Copula.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://github.com/tensorflow/probability/blob/main/tensorflow_probability/examples/jupyter_notebooks/Gaussian_Copula.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n </td>\n <td>\n <a href=\"https://storage.googleapis.com/tensorflow_docs/probability/tensorflow_probability/examples/jupyter_notebooks/Gaussian_Copula.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\" />Download notebook</a>\n </td>\n</table>",
"_____no_output_____"
]
],
[
[
"import numpy as np\nimport matplotlib.pyplot as plt\nimport tensorflow.compat.v2 as tf\ntf.enable_v2_behavior()\n\nimport tensorflow_probability as tfp\ntfd = tfp.distributions\ntfb = tfp.bijectors",
"_____no_output_____"
]
],
[
[
"A [copula](https://en.wikipedia.org/wiki/Copula_(probability_theory%29) is a classical approach for capturing the dependence between random variables. More formally, a copula is a multivariate distribution $C(U_1, U_2, ...., U_n)$ such that marginalizing gives $U_i \\sim \\text{Uniform}(0, 1)$.\n\n\nCopulas are interesting because we can use them to create multivariate distributions with arbitrary marginals. This is the recipe:\n\n* Using the [Probability Integral Transform](https://en.wikipedia.org/wiki/Probability_integral_transform) turns an arbitrary continuous R.V. $X$ into a uniform one $F_X(X)$, where $F_X$ is the CDF of $X$.\n* Given a copula (say bivariate) $C(U, V)$, we have that $U$ and $V$ have uniform marginal distributions.\n* Now given our R.V's of interest $X, Y$, create a new distribution $C'(X, Y) = C(F_X(X), F_Y(Y))$. The marginals for $X$ and $Y$ are the ones we desired.\n\nMarginals are univariate and thus may be easier to measure and/or model. A copula enables starting from marginals yet also achieving arbitrary correlation between dimensions.\n",
"_____no_output_____"
],
[
"# Gaussian Copula\n\nTo illustrate how copulas are constructed, consider the case of capturing dependence according to multivariate Gaussian correlations. A Gaussian Copula is one given by $C(u_1, u_2, ...u_n) = \\Phi_\\Sigma(\\Phi^{-1}(u_1), \\Phi^{-1}(u_2), ... \\Phi^{-1}(u_n))$ where $\\Phi_\\Sigma$ represents the CDF of a MultivariateNormal, with covariance $\\Sigma$ and mean 0, and $\\Phi^{-1}$ is the inverse CDF for the standard normal.\n\n\nApplying the normal's inverse CDF warps the uniform dimensions to be normally distributed. Applying the multivariate normal's CDF then squashes the distribution to be marginally uniform and with Gaussian correlations.\n\nThus, what we get is that the Gaussian Copula is a distribution over the unit hypercube $[0, 1]^n$ with uniform marginals.\n\nDefined as such, the Gaussian Copula can be implemented with `tfd.TransformedDistribution` and appropriate `Bijector`. That is, we are transforming a MultivariateNormal, via the use of the Normal distribution's inverse CDF, implemented by the [`tfb.NormalCDF`](https://www.tensorflow.org/probability/api_docs/python/tfp/bijectors/NormalCDF) bijector.",
"_____no_output_____"
],
[
"Below, we implement a Gaussian Copula with one simplifying assumption: that the covariance is parameterized\nby a Cholesky factor (hence a covariance for `MultivariateNormalTriL`). (One could use other `tf.linalg.LinearOperators` to encode different matrix-free assumptions.).",
"_____no_output_____"
]
],
[
[
"class GaussianCopulaTriL(tfd.TransformedDistribution):\n \"\"\"Takes a location, and lower triangular matrix for the Cholesky factor.\"\"\"\n def __init__(self, loc, scale_tril):\n super(GaussianCopulaTriL, self).__init__(\n distribution=tfd.MultivariateNormalTriL(\n loc=loc,\n scale_tril=scale_tril),\n bijector=tfb.NormalCDF(),\n validate_args=False,\n name=\"GaussianCopulaTriLUniform\")\n\n\n# Plot an example of this.\nunit_interval = np.linspace(0.01, 0.99, num=200, dtype=np.float32)\nx_grid, y_grid = np.meshgrid(unit_interval, unit_interval)\ncoordinates = np.concatenate(\n [x_grid[..., np.newaxis],\n y_grid[..., np.newaxis]], axis=-1)\n\npdf = GaussianCopulaTriL(\n loc=[0., 0.],\n scale_tril=[[1., 0.8], [0., 0.6]],\n).prob(coordinates)\n\n# Plot its density.\n\nplt.contour(x_grid, y_grid, pdf, 100, cmap=plt.cm.jet);",
"_____no_output_____"
]
],
[
[
"The power, however, from such a model is using the Probability Integral Transform, to use the copula on arbitrary R.V.s. In this way, we can specify arbitrary marginals, and use the copula to stitch them together.\n\nWe start with a model:\n\n$$\\begin{align*}\nX &\\sim \\text{Kumaraswamy}(a, b) \\\\\nY &\\sim \\text{Gumbel}(\\mu, \\beta)\n\\end{align*}$$\n\nand use the copula to get a bivariate R.V. $Z$, which has marginals [Kumaraswamy](https://en.wikipedia.org/wiki/Kumaraswamy_distribution) and [Gumbel](https://en.wikipedia.org/wiki/Gumbel_distribution).\n\n\nWe'll start by plotting the product distribution generated by those two R.V.s. This is just to serve as a comparison point to when we apply the Copula.",
"_____no_output_____"
]
],
[
[
"a = 2.0\nb = 2.0\ngloc = 0.\ngscale = 1.\n\nx = tfd.Kumaraswamy(a, b)\ny = tfd.Gumbel(loc=gloc, scale=gscale)\n\n# Plot the distributions, assuming independence\nx_axis_interval = np.linspace(0.01, 0.99, num=200, dtype=np.float32)\ny_axis_interval = np.linspace(-2., 3., num=200, dtype=np.float32)\nx_grid, y_grid = np.meshgrid(x_axis_interval, y_axis_interval)\n\npdf = x.prob(x_grid) * y.prob(y_grid)\n\n# Plot its density\n\nplt.contour(x_grid, y_grid, pdf, 100, cmap=plt.cm.jet);",
"_____no_output_____"
]
],
[
[
"# Joint Distribution with Different Marginals",
"_____no_output_____"
],
[
"Now we use a Gaussian copula to couple the distributions together, and plot that. Again our tool of choice is `TransformedDistribution` applying the appropriate `Bijector` to obtain the chosen marginals.\n\nSpecifically, we use a [`Blockwise`](https://www.tensorflow.org/probability/api_docs/python/tfp/bijectors/Blockwise) bijector which applies different bijectors at different parts of the vector (which is still a bijective transformation).",
"_____no_output_____"
],
[
"Now we can define the Copula we want. Given a list of target marginals (encoded as bijectors), we can easily construct\na new distribution that uses the copula and has the specified marginals.\n",
"_____no_output_____"
]
],
[
[
"class WarpedGaussianCopula(tfd.TransformedDistribution):\n \"\"\"Application of a Gaussian Copula on a list of target marginals.\n\n This implements an application of a Gaussian Copula. Given [x_0, ... x_n]\n which are distributed marginally (with CDF) [F_0, ... F_n],\n `GaussianCopula` represents an application of the Copula, such that the\n resulting multivariate distribution has the above specified marginals.\n\n The marginals are specified by `marginal_bijectors`: These are\n bijectors whose `inverse` encodes the CDF and `forward` the inverse CDF.\n\n block_sizes is a 1-D Tensor to determine splits for `marginal_bijectors`\n length should be same as length of `marginal_bijectors`.\n See tfb.Blockwise for details\n \"\"\"\n def __init__(self, loc, scale_tril, marginal_bijectors, block_sizes=None):\n super(WarpedGaussianCopula, self).__init__(\n distribution=GaussianCopulaTriL(loc=loc, scale_tril=scale_tril),\n bijector=tfb.Blockwise(bijectors=marginal_bijectors,\n block_sizes=block_sizes),\n validate_args=False,\n name=\"GaussianCopula\")",
"_____no_output_____"
]
],
[
[
"Finally, let's actually use this Gaussian Copula. We'll use a Cholesky of $\\begin{bmatrix}1 & 0\\\\\\rho & \\sqrt{(1-\\rho^2)}\\end{bmatrix}$, which will correspond to variances 1, and correlation $\\rho$ for the multivariate normal.\n\n\nWe'll look at a few cases: ",
"_____no_output_____"
]
],
[
[
"# Create our coordinates:\ncoordinates = np.concatenate(\n [x_grid[..., np.newaxis], y_grid[..., np.newaxis]], -1)\n\n\ndef create_gaussian_copula(correlation):\n # Use Gaussian Copula to add dependence.\n return WarpedGaussianCopula(\n loc=[0., 0.],\n scale_tril=[[1., 0.], [correlation, tf.sqrt(1. - correlation ** 2)]],\n # These encode the marginals we want. In this case we want X_0 has\n # Kumaraswamy marginal, and X_1 has Gumbel marginal.\n\n marginal_bijectors=[\n tfb.Invert(tfb.KumaraswamyCDF(a, b)),\n tfb.Invert(tfb.GumbelCDF(loc=0., scale=1.))])\n\n\n# Note that the zero case will correspond to independent marginals!\ncorrelations = [0., -0.8, 0.8]\ncopulas = []\nprobs = []\nfor correlation in correlations:\n copula = create_gaussian_copula(correlation)\n copulas.append(copula)\n probs.append(copula.prob(coordinates))\n\n\n# Plot it's density\n\nfor correlation, copula_prob in zip(correlations, probs):\n plt.figure()\n plt.contour(x_grid, y_grid, copula_prob, 100, cmap=plt.cm.jet)\n plt.title('Correlation {}'.format(correlation))",
"_____no_output_____"
]
],
[
[
"Finally, let's verify that we actually get the marginals we want.",
"_____no_output_____"
]
],
[
[
"def kumaraswamy_pdf(x):\n return tfd.Kumaraswamy(a, b).prob(np.float32(x))\n\ndef gumbel_pdf(x):\n return tfd.Gumbel(gloc, gscale).prob(np.float32(x))\n\n\ncopula_samples = []\nfor copula in copulas:\n copula_samples.append(copula.sample(10000))\n\nplot_rows = len(correlations)\nplot_cols = 2 # for 2 densities [kumarswamy, gumbel]\nfig, axes = plt.subplots(plot_rows, plot_cols, sharex='col', figsize=(18,12))\n\n# Let's marginalize out on each, and plot the samples.\n\nfor i, (correlation, copula_sample) in enumerate(zip(correlations, copula_samples)):\n k = copula_sample[..., 0].numpy()\n g = copula_sample[..., 1].numpy()\n\n\n _, bins, _ = axes[i, 0].hist(k, bins=100, density=True)\n axes[i, 0].plot(bins, kumaraswamy_pdf(bins), 'r--')\n axes[i, 0].set_title('Kumaraswamy from Copula with correlation {}'.format(correlation))\n\n _, bins, _ = axes[i, 1].hist(g, bins=100, density=True)\n axes[i, 1].plot(bins, gumbel_pdf(bins), 'r--')\n axes[i, 1].set_title('Gumbel from Copula with correlation {}'.format(correlation))\n ",
"_____no_output_____"
]
],
[
[
"# Conclusion\nAnd there we go! We've demonstrated that we can construct Gaussian Copulas using the `Bijector` API.\n\nMore generally, writing bijectors using the `Bijector` API and composing them with a distribution, can create rich families of distributions for flexible modelling.",
"_____no_output_____"
]
]
] | [
"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",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
]
] |
ece8a02392739a9877674436ed3af1c830f27aa8 | 8,253 | ipynb | Jupyter Notebook | s5/codes/wordnet.ipynb | gebakx/ihlt | 10c22f6e6c38a84772457d8c4093878ef917d9cf | [
"MIT"
] | null | null | null | s5/codes/wordnet.ipynb | gebakx/ihlt | 10c22f6e6c38a84772457d8c4093878ef917d9cf | [
"MIT"
] | null | null | null | s5/codes/wordnet.ipynb | gebakx/ihlt | 10c22f6e6c38a84772457d8c4093878ef917d9cf | [
"MIT"
] | 1 | 2019-11-20T22:58:32.000Z | 2019-11-20T22:58:32.000Z | 20.428218 | 101 | 0.469284 | [
[
[
"## WordNet reader",
"_____no_output_____"
]
],
[
[
"from nltk.corpus import wordnet as wn",
"_____no_output_____"
]
],
[
[
"### synsets",
"_____no_output_____"
]
],
[
[
"wn.synsets('age','n')",
"_____no_output_____"
],
[
"age = wn.synset('age.n.1')\nage",
"_____no_output_____"
]
],
[
[
"### definitions, examples and lemmas",
"_____no_output_____"
]
],
[
[
"age.definition()",
"_____no_output_____"
],
[
"age.examples()",
"_____no_output_____"
],
[
"ls = wn.synsets('age','n')\nll = ls[1].lemmas()\n[lemma.name() for lemma in ll]",
"_____no_output_____"
]
],
[
[
"### hyponyms and hypernyms",
"_____no_output_____"
]
],
[
[
"age.hyponyms()",
"_____no_output_____"
],
[
"age.hypernyms()",
"_____no_output_____"
],
[
"age.root_hypernyms()",
"_____no_output_____"
],
[
"hyper = lambda s: s.hypernyms()\nlist(age.closure(hyper))",
"_____no_output_____"
],
[
"age.tree(hyper)",
"_____no_output_____"
]
],
[
[
"### antonyms",
"_____no_output_____"
]
],
[
[
"good = wn.synset('good.a.01')\ngood.lemmas()[0].antonyms()",
"_____no_output_____"
]
],
[
[
"### all lexical relations",
"_____no_output_____"
]
],
[
[
"def getRelValue(name):\n method = getattr(age, rel)\n return method()\n \nlexRels = ['hypernyms', 'instance_hypernyms', 'hyponyms', 'instance_hyponyms', \\\n 'member_holonyms', 'substance_holonyms', 'part_holonyms', \\\n 'member_meronyms', 'substance_meronyms', 'part_meronyms', \\\n 'attributes', 'entailments', 'causes', 'also_sees', 'verb_groups', 'similar_tos']\nage = wn.synset('age.n.01')\n\nresults = {}\nfor rel in lexRels:\n val = getRelValue(rel)\n if val != []:\n results[rel] = val\nresults",
"_____no_output_____"
],
[
"for rel in results:\n for s in results[rel]:\n print(rel, s.name())",
"hyponyms bone_age.n.01\nhyponyms chronological_age.n.01\nhyponyms developmental_age.n.01\nhyponyms fetal_age.n.01\nhyponyms mental_age.n.01\nhyponyms newness.n.01\nhyponyms oldness.n.01\nhyponyms oldness.n.02\nhyponyms youngness.n.01\nhypernyms property.n.02\nattributes immature.a.04\nattributes mature.a.03\nattributes new.a.01\nattributes old.a.01\nattributes old.a.02\nattributes young.a.01\n"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
]
] |
ece8ab5884ac11aa0921c01c624547a1be880c09 | 657,840 | ipynb | Jupyter Notebook | Seaborn/Seaborn.ipynb | jimit105/Python-Libraries | 7e45e996454d323dad3aaa54875eef8eb865739b | [
"MIT"
] | 1 | 2018-10-02T13:36:56.000Z | 2018-10-02T13:36:56.000Z | Seaborn/Seaborn.ipynb | shubhanshu1995/Python-Libraries | ac4df5e28ac3bce2da4376b7989ffc96f2848fd9 | [
"MIT"
] | null | null | null | Seaborn/Seaborn.ipynb | shubhanshu1995/Python-Libraries | ac4df5e28ac3bce2da4376b7989ffc96f2848fd9 | [
"MIT"
] | 2 | 2019-07-15T06:57:54.000Z | 2021-11-17T05:00:21.000Z | 496.483019 | 88,512 | 0.939402 | [
[
[
"# Seaborn",
"_____no_output_____"
],
[
"Seaborn provides a high-level interface to Matplotlib, a powerful but sometimes unwieldy Python visualization library.\n\n> Seaborn is a complement, not a substitute, for Matplotlib. There are some tweaks that still require Matplotlib",
"_____no_output_____"
]
],
[
[
"# Importing Libraries\n\n# Pandas for managing datasets\nimport pandas as pd\n\n# Matplotlib for additional customization\nfrom matplotlib import pyplot as plt\n%matplotlib inline\n\n# Seaborn for plotting and styling\nimport seaborn as sns",
"_____no_output_____"
],
[
"# Importing dataset\n\ndf = pd.read_csv('Pokemon.csv', index_col=0)\n# index_col=0 simply means we'll treat the first column of the dataset as the ID column.",
"_____no_output_____"
],
[
"# Display first 5 observations\ndf.head()",
"_____no_output_____"
]
],
[
[
"## Seaborn's plotting functions",
"_____no_output_____"
],
[
"One of Seaborn's greatest strengths is its diversity of plotting functions. For instance, making a **scatter plot** is just one line of code using the ```lmplot()``` function.\n\nThere are two ways you can do so.\n\n* The first way (recommended) is to pass your DataFrame to the ```data=``` argument, while passing column names to the axes arguments, ```x=``` and ```y=```.\n* The second way is to directly pass in Series of data to the axes arguments",
"_____no_output_____"
]
],
[
[
"# Recommended way\nsns.lmplot(x='Attack', y='Defense', data=df)",
"_____no_output_____"
]
],
[
[
"Seaborn doesn't have a dedicated scatter plot function, which is why you see a diagonal line. We actually used Seaborn's function for fitting and plotting a **regression line**.",
"_____no_output_____"
],
[
"Here's how we can tweak the ```lmplot()```:\n\n* First, we'll set ```fit_reg=False``` to remove the regression line, since we only want a scatter plot.\n* Then, we'll set ```hue='Stage'``` to color our points by the Pokémon's evolution stage. \nThis hue argument is very useful because it allows you to express a third dimension of information using color.",
"_____no_output_____"
]
],
[
[
"# Scatterplot arguments\nsns.lmplot(x='Attack', y='Defense', data=df,\n fit_reg=False, # No regression line\n hue='Stage') # Color by evolution stage",
"_____no_output_____"
]
],
[
[
"## Customizing with Matplotlib",
"_____no_output_____"
],
[
"Setting axes limits:\n\n1. First, invoke your Seaborn plotting function as normal.\n2. Then, invoke Matplotlib's customization functions. In this case, we'll use its ```ylim()``` and ```xlim()``` functions.",
"_____no_output_____"
]
],
[
[
"# Plot using Seaborn\nsns.lmplot(x='Attack', y='Defense', data=df,\n fit_reg=False,\n hue='Stage')\n\n# Tweak using Matplotlib\nplt.ylim(0, None)\nplt.xlim(0, None)",
"_____no_output_____"
]
],
[
[
"## Role of Pandas",
"_____no_output_____"
],
[
"Pandas actually plays a very important role \nSeaborn's plotting functions benefit from a base DataFrame that's reasonably formatted.",
"_____no_output_____"
]
],
[
[
"sns.boxplot(data=df)",
"_____no_output_____"
],
[
"# Pre-format DataFrame\nstats_df = df.drop(['Total', 'Stage', 'Legendary'], axis=1)\n\n# New boxplot using stats_df\nsns.boxplot(data=stats_df)",
"_____no_output_____"
]
],
[
[
"## Seaborn themes",
"_____no_output_____"
],
[
"The default theme is called 'darkgrid'. \n\nNext, we'll change the theme to 'whitegrid' while making a violin plot. \n\n* Violin plots are useful alternatives to box plots.\n* They show the distribution (through the thickness of the violin) instead of only the summary statistics.",
"_____no_output_____"
]
],
[
[
"# Set theme\nsns.set_style('whitegrid')\n\n# Violin plot\nsns.violinplot(x='Type 1', y='Attack', data=df)",
"_____no_output_____"
]
],
[
[
"## Color palattes",
"_____no_output_____"
],
[
"Seaborn allows us to set custom color palettes. We can simply create an ordered Python list of color hex values.",
"_____no_output_____"
]
],
[
[
"pkmn_type_colors = ['#78C850', # Grass\n '#F08030', # Fire\n '#6890F0', # Water\n '#A8B820', # Bug\n '#A8A878', # Normal\n '#A040A0', # Poison\n '#F8D030', # Electric\n '#E0C068', # Ground\n '#EE99AC', # Fairy\n '#C03028', # Fighting\n '#F85888', # Psychic\n '#B8A038', # Rock\n '#705898', # Ghost\n '#98D8D8', # Ice\n '#7038F8', # Dragon\n ]",
"_____no_output_____"
],
[
"# Violin plot with Pokemon color palatte\nsns.violinplot(x='Type 1', y='Attack', data=df,\n palette=pkmn_type_colors) # Set color palatte",
"_____no_output_____"
],
[
"# Swarm plot with Pokemon color palatte\nsns.swarmplot(x='Type 1', y='Attack', data=df,\n palette=pkmn_type_colors)",
"_____no_output_____"
]
],
[
[
"## Overlaying plots",
"_____no_output_____"
],
[
"It's pretty straightforward to overlay plots using Seaborn, and it works the same way as with Matplotlib. Here's what we'll do:\n\n1. First, we'll make our figure larger using Matplotlib.\n2. Then, we'll plot the violin plot. However, we'll set ```inner=None``` to remove the bars inside the violins.\n3. Next, we'll plot the swarm plot. This time, we'll make the points black so they pop out more.\n4. Finally, we'll set a title using Matplotlib.",
"_____no_output_____"
]
],
[
[
"# Set figure size with Matplotlib\nplt.figure(figsize=(10,6))\n\n# Create plot\nsns.violinplot(x='Type 1', y='Attack', data=df,\n inner=None, #Remove the bars inside the violins\n palette=pkmn_type_colors)\n\nsns.swarmplot(x='Type 1', y='Attack', data=df,\n color='k', # Make points black\n alpha=0.7) # and slightly transparent\n\n# Set title with matplotlib\nplt.title('Attack by Type')",
"_____no_output_____"
]
],
[
[
"## Putting it all together",
"_____no_output_____"
],
[
"we could certainly repeat that chart for each stat. \nBut we can also combine the information into one chart... we just have to do some **data wrangling** with Pandas beforehand.",
"_____no_output_____"
]
],
[
[
"stats_df.head()",
"_____no_output_____"
]
],
[
[
"As you can see, all of our stats are in separate columns. Instead, we want to \"melt\" them into one column.\n\nTo do so, we'll use Pandas's ```melt()``` function. It takes 3 arguments:\n\n* First, the DataFrame to melt.\n* Second, ID variables to keep (Pandas will melt all of the other ones).\n* Finally, a name for the new, melted variable.",
"_____no_output_____"
]
],
[
[
"# Melt DataFrames\nmelted_df = pd.melt(stats_df,\n id_vars=['Name', 'Type 1', 'Type 2'], #Variables to keep\n var_name='Stat') # Name of melted variable\n\n#melted_df.head()\nmelted_df.tail()",
"_____no_output_____"
]
],
[
[
"All 6 of the stat columns have been \"melted\" into one, and the new Stat column indicates the original stat (HP, Attack, Defense, Sp. Attack, Sp. Defense, or Speed). \n\nFor example, it's hard to see here, but Bulbasaur now has 6 rows of data.",
"_____no_output_____"
]
],
[
[
"# Shape comparison\nprint(stats_df.shape)\nprint(melted_df.shape)",
"(151, 9)\n(906, 5)\n"
],
[
"# Swarm plot with melted_df\nsns.swarmplot(x='Stat', y='value', data=melted_df,\n hue='Type 1')",
"_____no_output_____"
]
],
[
[
"Finally, let's make a few final tweaks for a more readable chart:\n\n1. Enlarge the plot.\n2. Separate points by hue using the argument `split=True` .\n> `split` parameter has been renamed to `dodge`\n3. Use our custom Pokemon color palette.\n4. Adjust the y-axis limits to end at 0.\n5. Place the legend to the right.",
"_____no_output_____"
]
],
[
[
"# 1. Enlarge the plot\nplt.Figure(figsize=(10,6))\n\nsns.swarmplot(x='Stat', y='value', data=melted_df,\n hue='Type 1',\n dodge=True, # 2. Separate points by hue\n # split parameter has been renamed to dodge\n palette=pkmn_type_colors) # 3. Use Pokemon palatte\n\n# 4. Adjust the y-axis\nplt.ylim(0, 260)\n\n# 5. Place legend to the right\nplt.legend(bbox_to_anchor=(1,1), loc=2)",
"_____no_output_____"
]
],
[
[
"## Pokedex (mini-gallery)",
"_____no_output_____"
],
[
"### Heatmap\n> Heatmaps help you visualize matrix-like data.",
"_____no_output_____"
]
],
[
[
"# Calculate correlations\ncorr = stats_df.corr()\n\n# Heatmap\nsns.heatmap(corr)",
"_____no_output_____"
]
],
[
[
"### Histogram\n> Histograms allow you to plot the distributions of numeric variables.",
"_____no_output_____"
]
],
[
[
"#Distribution Plot (a.k.a. Histogram)\nsns.distplot(df.Attack)",
"_____no_output_____"
]
],
[
[
"### Bar Plot\n> Bar plots help you visualize the distributions of categorical variables.",
"_____no_output_____"
]
],
[
[
"# Count Plot (a.k.a. Bar Plot)\nsns.countplot(x='Type 1', data=df, palette=pkmn_type_colors)\n\n# Rotate x-labels\nplt.xticks(rotation=-45)",
"_____no_output_____"
]
],
[
[
"### Factor Plot\n> Factor plots make it easy to separate plots by categorical classes.",
"_____no_output_____"
]
],
[
[
"# Factor plot\ng = sns.factorplot(x='Type 1', y='Attack', data=df,\n hue='Stage', # Color by stage\n col='Stage', # Separate by stage\n kind='swarm')# Swarmplot\n\n# Rotate x-axis labels\ng.set_xticklabels(rotation=-45)\n\n#Doesn't work because only rotates last plot\n# plt.xticks(rotation=-45)",
"_____no_output_____"
]
],
[
[
"### Density Plot\n> Density plots display the distribution between two variables.",
"_____no_output_____"
]
],
[
[
"# Density plot\nsns.kdeplot(df.Attack, df.Defense)",
"_____no_output_____"
]
],
[
[
"### Joint DIstribution Plot\n> Joint distribution plots combine information from scatter plots and histograms to give you detailed information for bi-variate distributions.",
"_____no_output_____"
]
],
[
[
"# Joint Distribution Plot\nsns.jointplot(x='Attack', y='Defense', data=df)",
"_____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",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
ece8ac882bc5777ec7ee52f326ae940c49b55b0a | 746,606 | ipynb | Jupyter Notebook | SHBank/FinDataAnalysis_SHBank_ing.ipynb | waverDeep/FinDataAnalysis | 65d4b0987194317780078bf1c5c63e96385a0f8f | [
"MIT"
] | null | null | null | SHBank/FinDataAnalysis_SHBank_ing.ipynb | waverDeep/FinDataAnalysis | 65d4b0987194317780078bf1c5c63e96385a0f8f | [
"MIT"
] | 5 | 2021-08-31T08:29:50.000Z | 2021-09-04T09:28:50.000Z | SHBank/FinDataAnalysis_SHBank_ing.ipynb | waverDeep/FinDataAnalysis | 65d4b0987194317780078bf1c5c63e96385a0f8f | [
"MIT"
] | null | null | null | 363.135214 | 116,216 | 0.93389 | [
[
[
"# 3️⃣ 신한은행 - 서울시 지역단위 '소득', '지출', '금융자산' 정보",
"_____no_output_____"
],
[
"---",
"_____no_output_____"
],
[
"## 전체 데이터 파악하기",
"_____no_output_____"
]
],
[
[
"%matplotlib inline\n\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n\n# 한글 폰트 사용을 위해서 세팅\nfrom matplotlib import font_manager, rc\nfont_path = \"C:/Windows/Fonts/NanumBarunpenR.ttf\"\nfont = font_manager.FontProperties(fname=font_path).get_name()\nrc('font', family=font)",
"_____no_output_____"
],
[
"file_path = './신한은행_서울시 지역단위 \\'소득\\', \\'지출\\', \\'금융자산\\' 정보.csv'\ndf = pd.read_csv(file_path, encoding='cp949')\n\nprint(df.shape)\nprint(df.info())\ndf.head()",
"(1039568, 20)\n<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 1039568 entries, 0 to 1039567\nData columns (total 20 columns):\n # Column Non-Null Count Dtype \n--- ------ -------------- ----- \n 0 기준년월 1039568 non-null int64 \n 1 지역구 1039568 non-null object \n 2 법정동코드 1039568 non-null int64 \n 3 법정동 1039568 non-null object \n 4 집계구코드 1039568 non-null float64\n 5 나이 1039568 non-null int64 \n 6 성별 1039568 non-null int64 \n 7 직장인여부 1039568 non-null int64 \n 8 급여입금 1039568 non-null int64 \n 9 가맹점매출입금 1039568 non-null int64 \n 10 연금입금 1039568 non-null int64 \n 11 총소비금액 1039568 non-null int64 \n 12 총수신금액 1039568 non-null int64 \n 13 예적금금액 1039568 non-null int64 \n 14 신탁금액 1039568 non-null int64 \n 15 수익증권금액 1039568 non-null int64 \n 16 신용대출금액 1039568 non-null int64 \n 17 담보대출금액 1039568 non-null int64 \n 18 주택대출금액 1039568 non-null int64 \n 19 전세자금대출금액 1039568 non-null int64 \ndtypes: float64(1), int64(17), object(2)\nmemory usage: 158.6+ MB\nNone\n"
],
[
"df.columns",
"_____no_output_____"
]
],
[
[
"##### 결측 데이터 조회 - 없음",
"_____no_output_____"
]
],
[
[
"#df.isnull().sum()",
"_____no_output_____"
]
],
[
[
"---",
"_____no_output_____"
],
[
"#### 자치구 ('지역구') 확인하기",
"_____no_output_____"
]
],
[
[
"county = df['지역구'].unique()\n\n# 각 지역구가 맞는지 판별하기 위한 True/False\niscounty = []\nfor i in range(len(county)):\n iscounty.append(df['지역구'] == county[i])\n \n# 각 지역구의 데이터프레임\ncounties = []\nfor j in range(25):\n counties.append(df[iscounty[j]])",
"_____no_output_____"
]
],
[
[
"---",
"_____no_output_____"
],
[
"# ✍🏻",
"_____no_output_____"
],
[
"## 성별과 나이",
"_____no_output_____"
],
[
"### 📌 서울특별시 전체 인구 대상",
"_____no_output_____"
]
],
[
[
"### 서울특별시 전체 대상으로 1(남성)과 2(여성)의 인구가 매우 비슷함",
"_____no_output_____"
],
[
"print(df['성별'].value_counts())",
"1 525568\n2 514000\nName: 성별, dtype: int64\n"
],
[
"### 전체적인 인구로 보았을 때, 30대가 약 20만명으로 가장 많고, 70대가 14만명으로 가장 적다.\n## 중장년층인 4,5,60대에 비해 2,30대 청년층의 인구가 비교적 적다.",
"_____no_output_____"
],
[
"plt.figure(figsize=(5,5))\ndf['나이'].value_counts().plot.bar()\nplt.show()\n\nfor i in range(6):\n print(str(i+2) + '0대 :', len(df[df['나이'] == (i+2)]))",
"_____no_output_____"
],
[
"### 각 연령대 기준으로 성별 비율이 유사함\n## 20대, 30대는 여성이 더 많고 그 외는 모두 남성이 더 많음",
"_____no_output_____"
],
[
"ax = sns.countplot(x='나이', hue = '성별', data = df)",
"_____no_output_____"
],
[
"thirty = df['나이'] == 3\nman = df['성별'] == 1\nwoman = df['성별'] == 2\n\nprint(len(df[thirty & man]))\nprint(len(df[thirty & woman]))",
"97221\n98183\n"
]
],
[
[
"---",
"_____no_output_____"
],
[
"### 📌 각 자치구 개별적 대상",
"_____no_output_____"
]
],
[
[
"###",
"_____no_output_____"
],
[
"plt.figure(figsize=(20,20))\n\nfor i in range(25):\n plt.subplot(5, 5, i+1)\n counties[i]['나이'].value_counts().plot.bar()\n plt.ylim([0, 14000])\n plt.xticks(rotation=0)\n plt.title(county[i] + ' 연령대 분포')\n\nplt.show()",
"_____no_output_____"
],
[
"###",
"_____no_output_____"
],
[
"plt.figure(figsize=(20,20))\n\nfor i in range(25):\n plt.subplot(5, 5, i+1)\n sns.countplot(x='나이', hue = '성별', data = counties[i])\n plt.title(county[i] + ' 나이대 성별')\n\nplt.show()",
"_____no_output_____"
]
],
[
[
"---",
"_____no_output_____"
],
[
"# 🔔 총소비금액",
"_____no_output_____"
],
[
"### ⚪각 자치구 별 총소비금액이 0 이하인 데이터 확인하기",
"_____no_output_____"
]
],
[
[
"iszero = []\nsum = 0\nfor i in range(25):\n iszero.append(counties[i]['총소비금액'] <= 0)\n #print(county[i] + ' : ' + str(len(counties[i][iszero[i]])))\n sum += len(counties[i][iszero[i]])\n\nprint(\"\\n\\n총합 : \" + str(sum))",
"\n\n총합 : 246787\n"
]
],
[
[
"#### ⚫ 각 자치구 별 총소비금액 평균 (원본)",
"_____no_output_____"
]
],
[
[
"# 각 자치구 별 총소비금액 평균\nmean = []\nfor i in range(25):\n mean.append(counties[i]['총소비금액'].mean())\n #print(county[i] + ' : '+ str(counties[i]['총소비금액'].mean()))",
"_____no_output_____"
]
],
[
[
"---",
"_____no_output_____"
],
[
"#### ⚫ 각 자치구 별로 '총소비금액'이 0 이하인 데이터에 평균값(자치구 단위)으로 넣어주기",
"_____no_output_____"
]
],
[
[
"for i in range(25):\n counties[i].loc[iszero[i], '총소비금액'] = counties[i]['총소비금액'].mean()",
"C:\\Users\\serak\\anaconda3\\lib\\site-packages\\pandas\\core\\indexing.py:966: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n self.obj[item] = s\n"
]
],
[
[
"---",
"_____no_output_____"
],
[
"#### ⚫ 각 자치구 별 총소비금액 평균 (가공 이후)",
"_____no_output_____"
]
],
[
[
"for i in range(25):\n mean.append(counties[i]['총소비금액'].mean())\n #print(county[i] + ' : '+ str(counties[i]['총소비금액'].mean()))",
"_____no_output_____"
]
],
[
[
"---",
"_____no_output_____"
],
[
"# 🔔 총수신금액",
"_____no_output_____"
],
[
"### ⚪ '총수신금액'이 0 이하인 데이터 확인하기",
"_____no_output_____"
]
],
[
[
"iszero = []\nsum = 0\nfor i in range(25):\n iszero.append(counties[i]['총수신금액'] <= 0)\n #print(county[i] + ' : ' + str(len(counties[i][iszero[i]])))\n sum += len(counties[i][iszero[i]])\n\nprint(\"\\n\\n총합 : \" + str(sum))",
"\n\n총합 : 3\n"
]
],
[
[
"#### ⚫ 각 자치구 별 총수신금액",
"_____no_output_____"
]
],
[
[
"# 각 자치구 별 총수신금액 평균\nmean = []\nfor i in range(25):\n mean.append(counties[i]['총수신금액'].mean())\n #print(county[i] + ' : '+ str(counties[i]['총수신금액'].mean()))",
"_____no_output_____"
]
],
[
[
"---",
"_____no_output_____"
],
[
"# 🔔 직장인여부 / 급여입금",
"_____no_output_____"
],
[
"### ⚪ 자치구 별 직장인 수(급여입금 받는 인원수) 확인하기",
"_____no_output_____"
]
],
[
[
"# 자치구 별로 급여입금 받는 인원수 확인하기\nisworker = []\nsum = 0\nfor i in range(25):\n isworker.append(counties[i]['급여입금'] > 0)\n #print(county[i] + ' : ' + str(len(counties[i][isworker[i]])))\n sum += len(counties[i][isworker[i]])\n\nprint(\"\\n\\n총합 : \" + str(sum))",
"\n\n총합 : 36009\n"
]
],
[
[
"#### ⚫ 각 자치구 별 직장인 대상 급여입금 평균\n** 급여입금이 없는 사람들, 즉, 직장인에 해당하지 않는 사람들 제외",
"_____no_output_____"
]
],
[
[
"# 각 자치구 별 직장인 대상 급여입금 평균 \nmean = []\nfor i in range(25):\n mean.append(counties[i][isworker[i]]['급여입금'].mean())\n #print(county[i] + ' : '+ str(counties[i][isworker[i]]['급여입금'].mean()))",
"_____no_output_____"
]
],
[
[
"---",
"_____no_output_____"
],
[
"## 🟡 총소비금액 & 총수신금액 & 직장인 수 & 급여입금 - 막대 그래프, 꺾은선 그래프\n- 직장인 수\n- 총소비금액 & 급여입금 모두 0 데이터 제외 이후 평균 값으로 적용 !!\n- 급여입금은 직장인 대상 평균",
"_____no_output_____"
]
],
[
[
"worker = []\nfor i in range(25):\n worker.append(len(counties[i][isworker[i]]))",
"_____no_output_____"
],
[
"consumption = []\nfor i in range(25):\n consumption.append(counties[i]['총소비금액'].mean())",
"_____no_output_____"
],
[
"asset = []\nfor i in range(25):\n asset.append(counties[i]['총수신금액'].mean())",
"_____no_output_____"
],
[
"pay = []\nfor i in range(25):\n pay.append(counties[i][isworker[i]]['급여입금'].mean())",
"_____no_output_____"
]
],
[
[
"---",
"_____no_output_____"
],
[
"# ✍🏻 - 여기 정리하기",
"_____no_output_____"
],
[
"### 급여입금/총소비/총자산 순위",
"_____no_output_____"
]
],
[
[
"### 급여입금 순위\ndic_pay = {}\nfor i in range(25):\n dic_pay[county[i]] = int(pay[i])\n\ndic_pay = dict(sorted(dic_pay.items(), key=lambda x:x[1], reverse=True))\nfor i in range(25):\n print(str(i+1) +'위 : ' +list(dic_pay.keys())[i] + '\\t' + str(list(dic_pay.values())[i]) + ' 원')",
"1위 : 서초구\t4434539 원\n2위 : 강남구\t4397614 원\n3위 : 양천구\t4096984 원\n4위 : 용산구\t3993082 원\n5위 : 송파구\t3898295 원\n6위 : 중구\t3735404 원\n7위 : 종로구\t3684768 원\n8위 : 성북구\t3668333 원\n9위 : 강동구\t3586378 원\n10위 : 마포구\t3571755 원\n11위 : 성동구\t3542189 원\n12위 : 서대문구\t3522997 원\n13위 : 강북구\t3506619 원\n14위 : 영등포구\t3492250 원\n15위 : 광진구\t3398319 원\n16위 : 동작구\t3362681 원\n17위 : 구로구\t3261096 원\n18위 : 노원구\t3170992 원\n19위 : 강서구\t3162227 원\n20위 : 동대문구\t3139883 원\n21위 : 도봉구\t3057016 원\n22위 : 은평구\t3049636 원\n23위 : 관악구\t2925671 원\n24위 : 금천구\t2893865 원\n25위 : 중랑구\t2878703 원\n"
],
[
"### 총소비금액 순위\ndic_cons = {}\nfor i in range(25):\n dic_cons[county[i]] = int(consumption[i])\n\ndic_cons = dict(sorted(dic_cons.items(), key=lambda x:x[1], reverse=True))\nfor i in range(25):\n print(str(i+1) +'위 : ' +list(dic_cons.keys())[i] + '\\t' + str(list(dic_cons.values())[i]) + ' 원')",
"1위 : 강남구\t1914132 원\n2위 : 서초구\t1870463 원\n3위 : 용산구\t1708576 원\n4위 : 송파구\t1587059 원\n5위 : 성동구\t1581830 원\n6위 : 중구\t1576351 원\n7위 : 마포구\t1541429 원\n8위 : 종로구\t1504799 원\n9위 : 양천구\t1462725 원\n10위 : 강서구\t1452815 원\n11위 : 영등포구\t1451760 원\n12위 : 동작구\t1438760 원\n13위 : 광진구\t1431412 원\n14위 : 강동구\t1408536 원\n15위 : 성북구\t1403073 원\n16위 : 은평구\t1381959 원\n17위 : 서대문구\t1379245 원\n18위 : 관악구\t1371172 원\n19위 : 도봉구\t1366498 원\n20위 : 구로구\t1364992 원\n21위 : 중랑구\t1356135 원\n22위 : 동대문구\t1334980 원\n23위 : 금천구\t1333950 원\n24위 : 노원구\t1330321 원\n25위 : 강북구\t1273048 원\n"
],
[
"### 총수신금액 순위\ndic_ass = {}\nfor i in range(25):\n dic_ass[county[i]] = int(asset[i])\n\ndic_ass = dict(sorted(dic_ass.items(), key=lambda x:x[1], reverse=True))\nfor i in range(25):\n print(str(i+1) +'위 : ' +list(dic_ass.keys())[i] + '\\t' + str(list(dic_ass.values())[i]) + ' 원')",
"1위 : 서초구\t6559954 원\n2위 : 강남구\t6541343 원\n3위 : 송파구\t5233921 원\n4위 : 용산구\t5016620 원\n5위 : 성동구\t4701616 원\n6위 : 마포구\t4656763 원\n7위 : 중구\t4401267 원\n8위 : 종로구\t4385111 원\n9위 : 동작구\t4373611 원\n10위 : 양천구\t4336122 원\n11위 : 영등포구\t4263833 원\n12위 : 강서구\t4084911 원\n13위 : 성북구\t3974936 원\n14위 : 강동구\t3965753 원\n15위 : 광진구\t3886307 원\n16위 : 서대문구\t3821235 원\n17위 : 도봉구\t3765938 원\n18위 : 구로구\t3743025 원\n19위 : 노원구\t3682922 원\n20위 : 은평구\t3681698 원\n21위 : 관악구\t3555417 원\n22위 : 동대문구\t3440613 원\n23위 : 중랑구\t3341291 원\n24위 : 금천구\t3193268 원\n25위 : 강북구\t2945819 원\n"
]
],
[
[
"### 자치구 별 급여입금에 따른 총소비금액과 총수신금액",
"_____no_output_____"
]
],
[
[
"# x축 : 자치구 = county\n# y축 막대 : 급여입금 = pay\n# y축 선 green : 총소비금액\n# y축 선 skyblue : 총수신금액\n\nfig, ax1 = plt.subplots(figsize=(15,7))\n\nax1.bar(county, pay, color='lightgray', label='급여입금', alpha=0.5, width=0.7)\nax1.set_xlabel('자치구')\nax1.set_ylabel('급여입금')\n\nax2 = ax1.twinx()\nax2.plot(county, consumption,'-s', color='green', label='총소비금액', markersize=6, linewidth=3)\nax2.set_xlabel('자치구')\nax2.set_yticks([])\n\nax3 = ax1.twinx()\nax3.plot(county, asset,'-s', color='skyblue', label='총수신금액', markersize=6, linewidth=3)\nax3.set_xlabel('자치구')\nax3.set_yticks([])\n\nplt.show()",
"_____no_output_____"
]
],
[
[
"---",
"_____no_output_____"
],
[
"### (급여입금 - 총소비금액) 차이 비교하기",
"_____no_output_____"
]
],
[
[
"money = {}\nfor i in range(25):\n money[county[i]] = int(pay[i] - consumption[i])\n\ndic_money = dict(sorted(money.items(), key=lambda x:x[1], reverse=True))\nfor i in range(25):\n print(str(i+1) +'위 : ' +list(dic_money.keys())[i] + '\\t' + str(list(dic_money.values())[i]) + ' 원')",
"1위 : 양천구\t2634258 원\n2위 : 서초구\t2564075 원\n3위 : 강남구\t2483481 원\n4위 : 송파구\t2311235 원\n5위 : 용산구\t2284506 원\n6위 : 성북구\t2265259 원\n7위 : 강북구\t2233571 원\n8위 : 종로구\t2179968 원\n9위 : 강동구\t2177842 원\n10위 : 중구\t2159053 원\n11위 : 서대문구\t2143752 원\n12위 : 영등포구\t2040490 원\n13위 : 마포구\t2030326 원\n14위 : 광진구\t1966907 원\n15위 : 성동구\t1960358 원\n16위 : 동작구\t1923920 원\n17위 : 구로구\t1896103 원\n18위 : 노원구\t1840671 원\n19위 : 동대문구\t1804903 원\n20위 : 강서구\t1709412 원\n21위 : 도봉구\t1690518 원\n22위 : 은평구\t1667676 원\n23위 : 금천구\t1559915 원\n24위 : 관악구\t1554498 원\n25위 : 중랑구\t1522568 원\n"
]
],
[
[
"### 자치구 별 급여 대비 소비 경향 비교 (총소비금액 / 급여입금)\n- 급여, 총소비금액 모두 자치구 평균 값을 이용\n- 값이 높을 수록 소비 경향이 강함\n\n- 급여 대비 소비 경향이 있어야 할 것 같은 이유 \n: 강남구, 서초구와 같은 경우 자산이 많은 상위권에 속하고 그 자산에 비해 소비금액이 적은거인데 다른 구들에 비해 소비 경향이 너무 적게 나옴",
"_____no_output_____"
]
],
[
[
"money = {}\nfor i in range(25):\n money[county[i]] = round(consumption[i] / pay[i], 4)\n\nplt.figure(figsize=(15,5))\nplt.plot(list(money.keys()), list(money.values()))\nplt.show()\n\ndic_money = dict(sorted(money.items(), key=lambda x:x[1], reverse=True))\nfor i in range(25):\n print(str(i+1) +'위 : ' +list(dic_money.keys())[i] + '\\t' + str(list(dic_money.values())[i]))",
"_____no_output_____"
]
],
[
[
"### 자치구 별 자산 대비 소비 경향 비교 (총소비금액 / 총수신금액)\n- 총수신금액, 총소비금액 모두 자치구 평균 값을 이용\n- 값이 높을 수록 소비 경향이 강함",
"_____no_output_____"
]
],
[
[
"money = {}\nfor i in range(25):\n money[county[i]] = round(consumption[i] / asset[i], 4)\n\nplt.figure(figsize=(15,5))\nplt.plot(list(money.keys()), list(money.values()))\nplt.show()\n\ndic_money = dict(sorted(money.items(), key=lambda x:x[1], reverse=True))\nfor i in range(25):\n print(str(i+1) +'위 : ' +list(dic_money.keys())[i] + '\\t' + str(list(dic_money.values())[i]))",
"_____no_output_____"
]
],
[
[
"### 연령대 별 자산 대비 소비 경향 비교\n- 총수신금액 대비 총소비금액 비율 (총소비금액 / 총수신금액)\n- 값이 높을수록 소비경향 강함",
"_____no_output_____"
]
],
[
[
"### 강남구와 서초구에서만 연령대가 증가함에 따라 일정하게 감소함 (30대의 소비경향이 40대보다 큼)\n## 이외 다른 자치구는 모두 20대 -> 30대는 감소하였다가 30대->40대에서 소비경향이 증가하였고, \n# 그 이후에는 마찬가지로 일정하게 감소함",
"_____no_output_____"
],
[
"age_group = []\nfor i in range(2, 8):\n age_group.append(df['나이'] == i)\n\nman = df['성별'] == 1\nwoman = df['성별'] == 2 \n\ncounty_group = []\nfor i in range(25):\n county_group.append(df['지역구'] == county[i])",
"_____no_output_____"
],
[
"group = {}\nfor i in range(25):\n dic = {}\n for j in range(6):\n value = (df[age_group[j] & county_group[i]]['총소비금액']).mean() / (df[age_group[j] & county_group[i]]['총수신금액']).mean()\n dic[j+2] = round(value, 4) \n group[county[i]] = dic\n\nfor i in range(25):\n print(county[i], group[county[i]])\n plt.plot(list(group[county[i]].keys()), list(group[county[i]].values()))\n plt.show()",
"강남구 {2: 0.2961, 3: 0.2874, 4: 0.277, 5: 0.2523, 6: 0.1997, 7: 0.1549}\n"
]
],
[
[
"---",
"_____no_output_____"
],
[
"# ✍🏻",
"_____no_output_____"
],
[
"## 클ㄹㅓ스터링 - 총소비금액,총수신금액",
"_____no_output_____"
]
],
[
[
"from sklearn.cluster import KMeans\nfrom sklearn import preprocessing",
"_____no_output_____"
],
[
"clug = df.groupby('지역구')[['총수신금액', '총소비금액']].mean()\n\n# k=2,3,4\nfor i in range(2,5):\n estimator = KMeans(n_clusters = i)\n cluster_ids = estimator.fit_predict(clug)\n\n plt.scatter(clug['총소비금액'], clug['총수신금액'], c=cluster_ids)\n plt.xlabel(\"총소비금액\")\n plt.ylabel(\"총수신금액\")\n plt.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",
"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"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code"
]
] |
ece8baabef84f3086995fadc2123bb235c096682 | 9,997 | ipynb | Jupyter Notebook | site/en/r2/tutorials/estimators/keras_model_to_estimator.ipynb | crypdra/docs | 41ab06fd14b3a3dff933bb80b19ce46c7c5781cf | [
"Apache-2.0"
] | 2 | 2019-10-25T18:51:16.000Z | 2019-10-25T18:51:18.000Z | site/en/r2/tutorials/estimators/keras_model_to_estimator.ipynb | crypdra/docs | 41ab06fd14b3a3dff933bb80b19ce46c7c5781cf | [
"Apache-2.0"
] | null | null | null | site/en/r2/tutorials/estimators/keras_model_to_estimator.ipynb | crypdra/docs | 41ab06fd14b3a3dff933bb80b19ce46c7c5781cf | [
"Apache-2.0"
] | null | null | null | 29.576923 | 301 | 0.517455 | [
[
[
"##### Copyright 2019 The TensorFlow Authors.",
"_____no_output_____"
]
],
[
[
"#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.",
"_____no_output_____"
]
],
[
[
"# How-to create an Estimator from a Keras model",
"_____no_output_____"
],
[
"<table class=\"tfo-notebook-buttons\" align=\"left\">\n <td>\n <a target=\"_blank\" href=\"https://www.tensorflow.org/beta/tutorials/estimators/keras_model_to_estimator\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />View on TensorFlow.org</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/r2/tutorials/estimators/keras_model_to_estimator.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://github.com/tensorflow/docs/blob/master/site/en/r2/tutorials/estimators/keras_model_to_estimator.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n </td>\n <td>\n <a href=\"https://storage.googleapis.com/tensorflow_docs/docs/site/en/r2/tutorials/estimators/keras_model_to_estimator.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\" />Download notebook</a>\n </td>\n</table>",
"_____no_output_____"
],
[
"## Overview\n\nTensorFlow Estimators are fully supported in TensorFlow, and can be created from new and existing `tf.keras` models. This tutorial contains a complete, minimal example of that process.",
"_____no_output_____"
],
[
"## Setup",
"_____no_output_____"
]
],
[
[
"from __future__ import absolute_import, division, print_function, unicode_literals",
"_____no_output_____"
],
[
"try:\n # %tensorflow_version only exists in Colab.\n %tensorflow_version 2.x\nexcept Exception:\n pass",
"_____no_output_____"
],
[
"import tensorflow as tf\n\nimport numpy as np\nimport tensorflow_datasets as tfds",
"_____no_output_____"
]
],
[
[
"### Create a simple Keras model.",
"_____no_output_____"
],
[
"In Keras, you assemble *layers* to build *models*. A model is (usually) a graph\nof layers. The most common type of model is a stack of layers: the\n`tf.keras.Sequential` model.\n\nTo build a simple, fully-connected network (i.e. multi-layer perceptron):",
"_____no_output_____"
]
],
[
[
"model = tf.keras.models.Sequential([\n tf.keras.layers.Dense(16, activation='relu', input_shape=(4,)),\n tf.keras.layers.Dropout(0.2),\n tf.keras.layers.Dense(1, activation='sigmoid')\n])",
"_____no_output_____"
]
],
[
[
"Compile the model and get a summary.",
"_____no_output_____"
]
],
[
[
"model.compile(loss='categorical_crossentropy', optimizer='adam')\nmodel.summary()",
"_____no_output_____"
]
],
[
[
"### Create an input function\n\nUse the [Datasets API](../../guide/data.md) to scale to large datasets\nor multi-device training.\n\nEstimators need control of when and how their input pipeline is built. To allow this, they require an \"Input function\" or `input_fn`. The `Estimator` will call this function with no arguments. The `input_fn` must return a `tf.data.Dataset`.",
"_____no_output_____"
]
],
[
[
"def input_fn():\n split = tfds.Split.TRAIN\n dataset = tfds.load('iris', split=split, as_supervised=True)\n dataset = dataset.map(lambda features, labels: ({'dense_input':features}, labels))\n dataset = dataset.batch(32).repeat()\n return dataset",
"_____no_output_____"
]
],
[
[
"Test out your `input_fn`",
"_____no_output_____"
]
],
[
[
"for features_batch, labels_batch in input_fn().take(1):\n print(features_batch)\n print(labels_batch)",
"_____no_output_____"
]
],
[
[
"### Create an Estimator from the tf.keras model.\n\nA `tf.keras.Model` can be trained with the `tf.estimator` API by converting the\nmodel to an `tf.estimator.Estimator` object with\n`tf.keras.estimator.model_to_estimator`.",
"_____no_output_____"
]
],
[
[
"model_dir = \"/tmp/tfkeras_example/\"\nkeras_estimator = tf.keras.estimator.model_to_estimator(\n keras_model=model, model_dir=model_dir)",
"_____no_output_____"
]
],
[
[
"Train and evaluate the estimator.",
"_____no_output_____"
]
],
[
[
"keras_estimator.train(input_fn=input_fn, steps=25)\neval_result = keras_estimator.evaluate(input_fn=input_fn, steps=10)\nprint('Eval result: {}'.format(eval_result))",
"_____no_output_____"
]
]
] | [
"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",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
ece8c301514eb56ad0bf94bf3e4397821122ac36 | 7,289 | ipynb | Jupyter Notebook | Week2-GraphTheory/Pset2_GraphTheory.ipynb | sarpcelikel/brain-networks-course | e9474b0dc9b2b70a9f2a1fb9176a869a14718940 | [
"MIT"
] | null | null | null | Week2-GraphTheory/Pset2_GraphTheory.ipynb | sarpcelikel/brain-networks-course | e9474b0dc9b2b70a9f2a1fb9176a869a14718940 | [
"MIT"
] | null | null | null | Week2-GraphTheory/Pset2_GraphTheory.ipynb | sarpcelikel/brain-networks-course | e9474b0dc9b2b70a9f2a1fb9176a869a14718940 | [
"MIT"
] | null | null | null | 28.69685 | 376 | 0.592262 | [
[
[
"### Week 2 Problem Set: Graph Theory\n\nIn this exercise we will work with real data from the C. Elegans nervous system, using data shared by the [WormAtlas](http://www.wormatlas.org/) database. We will treat it as an undirected connectome for the purposes of this exercise.\n\nFor some problems you will be provided with skeleton code - fill in the lines marked ```...``` with appropriate code to solve problem.",
"_____no_output_____"
]
],
[
[
"import pandas,numpy\nimport os,sys\nimport networkx as nx\nimport matplotlib.pyplot as plt\nimport scipy.stats\n\nfrom brainnetworks.utils import mk_random_graph\n\n%matplotlib inline\n\n# read the data from Wormatlas.org: see section 2.1 of http://www.wormatlas.org/neuronalwiring.html for details\n\ncelegans_connectome=pandas.read_excel('http://www.wormatlas.org/images/NeuronConnect.xls')\n\n# set up the graph\nGd = nx.DiGraph()\nfor i in celegans_connectome.index:\n Gd.add_edge(celegans_connectome.loc[i]['Neuron 1'],celegans_connectome.loc[i]['Neuron 2'])\n \nGu=Gd.to_undirected()\n\n# the graph has two connected components, so we will just keep the giant component\ncomponents=nx.connected_component_subgraphs(Gu)\nG=next(components)\n",
"_____no_output_____"
]
],
[
[
"### Problem 1:\n\na. Plot a histogram of the degree distribution, and print out the mean and maximum degree\n",
"_____no_output_____"
],
[
"b. Compute the average clustering coefficient for the connectome",
"_____no_output_____"
]
],
[
[
"ce_clustering = ...\nprint(ce_clustering)",
"_____no_output_____"
]
],
[
[
"c. Compute the average path length for the connectome",
"_____no_output_____"
]
],
[
[
"ce_avgpathlength = ...\nprint(ce_avgpathlength)",
"_____no_output_____"
]
],
[
[
"#### Problem 2\n\nFirst, use the provided code to create 100 random graphs with the same size as the C. Elegans connectome. For each graph, we compute its average clustering, average shortest path length, and maximum degree, and store those to a numpy array. (This may take a few minutes to run.)",
"_____no_output_____"
]
],
[
[
"# PROVIDED CODE\nnruns=100\nmeasures=['clustering','avgpathlength','maxdegree']\nresults=pandas.DataFrame(numpy.zeros((nruns,len(measures))),\n columns=measures)\n\nfor i in range(nruns):\n G_rand = mk_random_graph(G)\n results.iloc[i]['clustering']=nx.average_clustering(G_rand)\n results.iloc[i]['avgpathlength']=nx.average_shortest_path_length(G_rand)\n results.iloc[i]['maxdegree']=numpy.max([G_rand.degree[i] for i in G_rand.nodes])\n ",
"_____no_output_____"
]
],
[
[
"a. Compute the tail probability of the observed values of cluster and path length for the C. elegans network, in comparison to the random network results. That is, what is the probability of a value as or more extreme than the observed value wihtin the random graph distribution? You may find the function ```scipy.stats.percentileofscore()``` useful for this purpose.",
"_____no_output_____"
]
],
[
[
"### PROVIDED CODE: \n\np_clustering=...\nprint('Observed:',ce_clustering,'Random:',results['clustering'].mean(),'P<',p_clustering)\n\np_avgpathlength=...\nprint('Observed:',ce_avgpathlength,'Random:',results['avgpathlength'].mean(),'P<',p_avgpathlength)\n\np_maxdegree=...\nprint('Observed:',numpy.max(degree_vals),'Random:',results['maxdegree'].mean(),'P<',p_maxdegree)\n",
"_____no_output_____"
]
],
[
[
"Based on the results of this analysis, do you think that the C. Elegans connectome is a \"small world\" network\"? explain your answer.",
"_____no_output_____"
],
[
"ANSWER:\n ",
"_____no_output_____"
],
[
"### Problem 3:\n\nDetermine which neuron is the most important based on these four criteria:\n\n- degree centrality\n- betweenness centrality\n- closeness centrality\n- eigenvector centrality\n\nBecause networkx returns a dictionary when it computes centrality measures, we have provided a utility function to return the entry with the largest value.",
"_____no_output_____"
]
],
[
[
"### PROVIDED CODE\n\ndef get_max_from_dict(d):\n \"\"\"\n return the dict entry with the max value\n after https://stackoverflow.com/questions/268272/getting-key-with-maximum-value-in-dictionary\n \"\"\"\n return max(d, key=lambda key: d[key])\n\ncentral_nodes={}\n# compute degree centrality\ncentral_nodes['degree']=get_max_from_dict(...)\n# compute eigenvector centrality\ncentral_nodes['eigenvector']=get_max_from_dict(...)\n# compute betweenness centrality\ncentral_nodes['betweenness']=get_max_from_dict(...)\n# compute closeness centrality\ncentral_nodes['closeness']=get_max_from_dict(...)\n\nprint(central_nodes)",
"_____no_output_____"
]
],
[
[
"You should see that the most central node differs between the different measures. Given what you know about those measures, explain why this might be the case.",
"_____no_output_____"
],
[
"ANSWER:\n\n",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
]
] |
ece8de4bbf4fe1fd7bd0d911e14311a8adc1af85 | 30,363 | ipynb | Jupyter Notebook | notebooks/Introduction.ipynb | lwcook/horsetail-matching | f3d5f8d01249debbca978f412ce4eae017458119 | [
"MIT"
] | 2 | 2017-05-17T17:07:08.000Z | 2018-03-29T12:42:36.000Z | notebooks/Introduction.ipynb | lwcook/horsetail-matching | f3d5f8d01249debbca978f412ce4eae017458119 | [
"MIT"
] | null | null | null | notebooks/Introduction.ipynb | lwcook/horsetail-matching | f3d5f8d01249debbca978f412ce4eae017458119 | [
"MIT"
] | null | null | null | 112.873606 | 12,618 | 0.859105 | [
[
[
"Horsetail matching is a method for optimizing under uncertainty. \n\nWe are looking to minimize a quantity of interest, q, which is a function of design variables (that we can control), x, and uncertain variables (which are uncontrollable), u. Since u is uncertain, q at a given design x is also uncertain. We therefore need to define some measure of the behaviour of q under uncertainty to minimize instead. With horseail matching this measure is the difference between the bounds on the CDF (the horsetail plot) of q for a given design and targets for these bounds. \n\nFor further details see the website: http://www-edc.eng.cam.ac.uk/aerotools/horsetailmatching/ which has links to the relevant publications. \n\n**This tutorial illustrates how to setup and run a simple horsetail matching optimization.** \nNote that for clarification on how any of the module works, see the documentation available at: http://www-edc.eng.cam.ac.uk/aerotools/horsetailmatching/documentation/\n\nTo begin with, we will only consider probabilistic uncertainties. This requires a probability distribution to be assigned to all of our uncertain parameters, and this is propagated to give a probability distribution of our quantity of interest for a given design x. Therefore the horsetail plot is the CDF itself and we are essentially doing CDF matching.\n\nFirstly we need to import the functions and classes we will use from the horsetail matching module...",
"_____no_output_____"
]
],
[
[
"from horsetailmatching import UncertainParameter, UniformParameter, GaussianParameter, HorsetailMatching\nfrom horsetailmatching.demoproblems import TP1",
"_____no_output_____"
]
],
[
[
"A horsetail matching object requires a function that takes two arguments: the value of the design variables, and the value of the uncertainties; it should return the value quantity of interest. Here we will use a test problem that comes that is part of the horsetail matching module. In reality, this function is likely to be a computationally expensive simulation, for example a 3D computational fluid dynamics simulation of a wing.",
"_____no_output_____"
]
],
[
[
"my_func = TP1\nprint TP1(x=[0, 1], u=[1, 0])",
"0.1\n"
]
],
[
[
"Next we must define the input uncertainties to the problem, by creating horsetail matching parameters. We can assign the parameters a distribution by using the base UncertainParameter class and defining a pdf function, or we can use the specific distribution subclasses such as UniformParameter and GaussianParameter. \n\nHere we create a uniformly distributed uncertainty and a gaussian uncertainty.\n\nThen we create the HorsetailMatching object which will do the evalation of the horsetail matching metric. We can specify the target inverse CDF using the ftarget argument (by default a standard target of t(h) = 0 is used). ",
"_____no_output_____"
]
],
[
[
"def myPDF(u):\n if u > 1 or u < -1:\n return 0\n else:\n return 0.5\n\nu_uniform = UncertainParameter(myPDF, lower_bound=-1, upper_bound=1)\nu_gaussian = GaussianParameter(mean=0, standard_deviation=1)\n\ndef my_target(h): \n return 0\n\ntheHM = HorsetailMatching(my_func, [u_uniform, u_gaussian], ftarget=my_target)",
"_____no_output_____"
]
],
[
[
"Now we use the evalMetric method to evaluate the horsetail matching metric at a design point:",
"_____no_output_____"
]
],
[
[
"print(theHM.evalMetric(x=[1,1]))",
"1.5954675519106958\n"
]
],
[
[
"We can use the getHorsetail() method to visualize the behaviour under uncertainty. It returns plottable lists of values for the two horsetail curves (the upper and lower bounds on the CDF) as the first two returned tuples. In this case the two bounds are coincidental and the horsetail plot is the CDF. \n\nWe can then plot this using the matplotlib module for plotting in python. ",
"_____no_output_____"
]
],
[
[
"import matplotlib.pyplot as plt\n(x1, y1, t1), (x2, y2, t2), _ = theHM.getHorsetail()\nplt.plot(x1, y1, 'b', label='CDF')\nplt.plot(t1, y1, 'k--', label='Target')\nplt.xlim([-1, 6])\nplt.xlabel('Quantity of Interest')\nplt.legend(loc='lower right')\nplt.show()",
"_____no_output_____"
]
],
[
[
"Now if we want to use this within an optimization, its a simple as passing theHM.evalMetric to whichever optimizer we like. For example, using the scipy optimize module's minimize function:",
"_____no_output_____"
]
],
[
[
"from scipy.optimize import minimize\n\nsolution = minimize(theHM.evalMetric, x0=[3,2], method='Nelder-Mead')\nprint(solution)",
" status: 0\n nfev: 107\n success: True\n fun: 0.0\n x: array([-2.46257592, 2.46257594])\n message: 'Optimization terminated successfully.'\n nit: 54\n"
],
[
"(x1, y1, t1), (x2, y2, t2), _ = theHM.getHorsetail()\nplt.plot(x1, y1, 'b', label='CDF')\nplt.plot([theHM.ftarget(y) for y in y1], y1, 'k--', label='Target')\nplt.xlim([-1, 6])\nplt.xlabel('Quantity of Interest')\nplt.legend(loc='lower right')\nplt.show()",
"_____no_output_____"
]
],
[
[
"For this simple test problem the minimum is where the CDF is a step function at 0, and so the horsetail matching metric is also 0. ",
"_____no_output_____"
],
[
"This concludes our introduction to horsetail matching. \n\nIn the next tutorial, we do horsetail matching when not all of our uncertainties can be represented probabilistically: http://nbviewer.jupyter.org/github/lwcook/horsetail-matching/blob/master/notebooks/MixedUncertainties.ipynb\n\nFor other tutorials, please visit http://www-edc.eng.cam.ac.uk/aerotools/horsetailmatching/",
"_____no_output_____"
]
]
] | [
"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",
"markdown"
]
] |
ece9045c6df82ed6b86742f43d9cf8f2aab311fe | 1,573 | ipynb | Jupyter Notebook | Python basics practice/Python 3 (23)/While Loops and Incrementing - Exercise_Py3.ipynb | rachithh/data-science | 1f7c5678094fc3acfda30cb00f9de93a2974f505 | [
"MIT"
] | null | null | null | Python basics practice/Python 3 (23)/While Loops and Incrementing - Exercise_Py3.ipynb | rachithh/data-science | 1f7c5678094fc3acfda30cb00f9de93a2974f505 | [
"MIT"
] | null | null | null | Python basics practice/Python 3 (23)/While Loops and Incrementing - Exercise_Py3.ipynb | rachithh/data-science | 1f7c5678094fc3acfda30cb00f9de93a2974f505 | [
"MIT"
] | null | null | null | 18.72619 | 96 | 0.506039 | [
[
[
"## While Loops and Incrementing",
"_____no_output_____"
],
[
"*Suggested Answers follow (usually there are multiple ways to solve a problem in Python).*",
"_____no_output_____"
],
[
"Create a while loop that will print all odd numbers from 0 to 30 on the same row. \n<br />\n*Hint: There are two ways in which you can create the odd values!*",
"_____no_output_____"
]
],
[
[
"x=1\nwhile x<=30:\n print(x,end=' ')\n x=x+2",
"1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 "
]
]
] | [
"markdown",
"code"
] | [
[
"markdown",
"markdown",
"markdown"
],
[
"code"
]
] |
ece90673266378e1016498d5a6008e43c5d5dfae | 92,034 | ipynb | Jupyter Notebook | Writing Functions in Python.ipynb | Yuleii/programming_notebook | 5d4ba849fcff1ea6dcdd0e2259193b2509b17026 | [
"MIT"
] | 2 | 2021-08-31T20:59:00.000Z | 2022-03-13T09:59:38.000Z | Writing Functions in Python.ipynb | Yuleii/programming_notebook | 5d4ba849fcff1ea6dcdd0e2259193b2509b17026 | [
"MIT"
] | null | null | null | Writing Functions in Python.ipynb | Yuleii/programming_notebook | 5d4ba849fcff1ea6dcdd0e2259193b2509b17026 | [
"MIT"
] | 2 | 2021-09-25T12:50:24.000Z | 2022-03-21T08:27:03.000Z | 28.007912 | 13,548 | 0.512517 | [
[
[
"<h1>Table of Contents<span class=\"tocSkip\"></span></h1>\n<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Best-Practices\" data-toc-modified-id=\"Best-Practices-1\"><span class=\"toc-item-num\">1 </span>Best Practices</a></span><ul class=\"toc-item\"><li><span><a href=\"#Docstrings\" data-toc-modified-id=\"Docstrings-1.1\"><span class=\"toc-item-num\">1.1 </span>Docstrings</a></span><ul class=\"toc-item\"><li><span><a href=\"#Anatomy-of-a-docstring\" data-toc-modified-id=\"Anatomy-of-a-docstring-1.1.1\"><span class=\"toc-item-num\">1.1.1 </span>Anatomy of a docstring</a></span></li><li><span><a href=\"#Docstring-formats\" data-toc-modified-id=\"Docstring-formats-1.1.2\"><span class=\"toc-item-num\">1.1.2 </span>Docstring formats</a></span><ul class=\"toc-item\"><li><span><a href=\"#Google-style\" data-toc-modified-id=\"Google-style-1.1.2.1\"><span class=\"toc-item-num\">1.1.2.1 </span>Google style</a></span></li><li><span><a href=\"#Numpydoc\" data-toc-modified-id=\"Numpydoc-1.1.2.2\"><span class=\"toc-item-num\">1.1.2.2 </span><a href=\"https://numpydoc.readthedocs.io/en/latest/format.html\" target=\"_blank\">Numpydoc</a></a></span></li></ul></li><li><span><a href=\"#Retrieving-docstrings\" data-toc-modified-id=\"Retrieving-docstrings-1.1.3\"><span class=\"toc-item-num\">1.1.3 </span>Retrieving docstrings</a></span></li><li><span><a href=\"#Exercise-1\" data-toc-modified-id=\"Exercise-1-1.1.4\"><span class=\"toc-item-num\">1.1.4 </span>Exercise 1</a></span></li><li><span><a href=\"#Exercise-2\" data-toc-modified-id=\"Exercise-2-1.1.5\"><span class=\"toc-item-num\">1.1.5 </span>Exercise 2</a></span></li></ul></li><li><span><a href=\"#DRY-and-"Do-One-Thing"\" data-toc-modified-id=\"DRY-and-"Do-One-Thing"-1.2\"><span class=\"toc-item-num\">1.2 </span>DRY and \"Do One Thing\"</a></span><ul class=\"toc-item\"><li><span><a href=\"#Don't-repeat-yourself-(DRY)\" data-toc-modified-id=\"Don't-repeat-yourself-(DRY)-1.2.1\"><span class=\"toc-item-num\">1.2.1 </span>Don't repeat yourself (DRY)</a></span></li><li><span><a href=\"#Do-One-Thing\" data-toc-modified-id=\"Do-One-Thing-1.2.2\"><span class=\"toc-item-num\">1.2.2 </span>Do One Thing</a></span></li></ul></li><li><span><a href=\"#Pass-by-assignment\" data-toc-modified-id=\"Pass-by-assignment-1.3\"><span class=\"toc-item-num\">1.3 </span>Pass by assignment</a></span><ul class=\"toc-item\"><li><span><a href=\"#surprising-example\" data-toc-modified-id=\"surprising-example-1.3.1\"><span class=\"toc-item-num\">1.3.1 </span>surprising example</a></span></li><li><span><a href=\"#Mutable-default-arguments-are-dangerous\" data-toc-modified-id=\"Mutable-default-arguments-are-dangerous-1.3.2\"><span class=\"toc-item-num\">1.3.2 </span>Mutable default arguments are dangerous</a></span></li><li><span><a href=\"#Best-practice-for-default-arguments\" data-toc-modified-id=\"Best-practice-for-default-arguments-1.3.3\"><span class=\"toc-item-num\">1.3.3 </span>Best practice for default arguments</a></span></li></ul></li></ul></li><li><span><a href=\"#Context-Managers\" data-toc-modified-id=\"Context-Managers-2\"><span class=\"toc-item-num\">2 </span>Context Managers</a></span><ul class=\"toc-item\"><li><span><a href=\"#Using-context-managers\" data-toc-modified-id=\"Using-context-managers-2.1\"><span class=\"toc-item-num\">2.1 </span>Using context managers</a></span><ul class=\"toc-item\"><li><span><a href=\"#A-real-world-example\" data-toc-modified-id=\"A-real-world-example-2.1.1\"><span class=\"toc-item-num\">2.1.1 </span>A real-world example</a></span></li><li><span><a href=\"#Exercise:-The-speed-of-cats\" data-toc-modified-id=\"Exercise:-The-speed-of-cats-2.1.2\"><span class=\"toc-item-num\">2.1.2 </span>Exercise: The speed of cats</a></span></li></ul></li><li><span><a href=\"#Writing-context-managers\" data-toc-modified-id=\"Writing-context-managers-2.2\"><span class=\"toc-item-num\">2.2 </span>Writing context managers</a></span><ul class=\"toc-item\"><li><span><a href=\"#How-to-create-a-context-manager\" data-toc-modified-id=\"How-to-create-a-context-manager-2.2.1\"><span class=\"toc-item-num\">2.2.1 </span>How to create a context manager</a></span></li><li><span><a href=\"#The-"yield"-keyword\" data-toc-modified-id=\"The-"yield"-keyword-2.2.2\"><span class=\"toc-item-num\">2.2.2 </span>The \"yield\" keyword</a></span></li><li><span><a href=\"#Setup-and-teardown\" data-toc-modified-id=\"Setup-and-teardown-2.2.3\"><span class=\"toc-item-num\">2.2.3 </span>Setup and teardown</a></span></li><li><span><a href=\"#Yielding-a-value-or-None\" data-toc-modified-id=\"Yielding-a-value-or-None-2.2.4\"><span class=\"toc-item-num\">2.2.4 </span>Yielding a value or None</a></span></li><li><span><a href=\"#Exercise:-The-timer()-context-manager\" data-toc-modified-id=\"Exercise:-The-timer()-context-manager-2.2.5\"><span class=\"toc-item-num\">2.2.5 </span>Exercise: The timer() context manager</a></span></li><li><span><a href=\"#Exercise:-A-read-only-open()-context-manager\" data-toc-modified-id=\"Exercise:-A-read-only-open()-context-manager-2.2.6\"><span class=\"toc-item-num\">2.2.6 </span>Exercise: A read-only open() context manager</a></span></li></ul></li><li><span><a href=\"#Advanced-topics\" data-toc-modified-id=\"Advanced-topics-2.3\"><span class=\"toc-item-num\">2.3 </span>Advanced topics</a></span><ul class=\"toc-item\"><li><span><a href=\"#Nested-contexts\" data-toc-modified-id=\"Nested-contexts-2.3.1\"><span class=\"toc-item-num\">2.3.1 </span>Nested contexts</a></span></li><li><span><a href=\"#Handling-errors\" data-toc-modified-id=\"Handling-errors-2.3.2\"><span class=\"toc-item-num\">2.3.2 </span>Handling errors</a></span></li><li><span><a href=\"#Context-manager-patterns\" data-toc-modified-id=\"Context-manager-patterns-2.3.3\"><span class=\"toc-item-num\">2.3.3 </span>Context manager patterns</a></span></li><li><span><a href=\"#Exercise:-Scraping-the-NASDAQ\" data-toc-modified-id=\"Exercise:-Scraping-the-NASDAQ-2.3.4\"><span class=\"toc-item-num\">2.3.4 </span>Exercise: Scraping the NASDAQ</a></span></li><li><span><a href=\"#Exercise:-Changing-the-working-directory\" data-toc-modified-id=\"Exercise:-Changing-the-working-directory-2.3.5\"><span class=\"toc-item-num\">2.3.5 </span>Exercise: Changing the working directory</a></span></li></ul></li></ul></li><li><span><a href=\"#Decorators\" data-toc-modified-id=\"Decorators-3\"><span class=\"toc-item-num\">3 </span>Decorators</a></span><ul class=\"toc-item\"><li><span><a href=\"#Functions-are-objects\" data-toc-modified-id=\"Functions-are-objects-3.1\"><span class=\"toc-item-num\">3.1 </span>Functions are objects</a></span><ul class=\"toc-item\"><li><span><a href=\"#Functions-are-just-another-type-of-object\" data-toc-modified-id=\"Functions-are-just-another-type-of-object-3.1.1\"><span class=\"toc-item-num\">3.1.1 </span>Functions are just another type of object</a></span></li><li><span><a href=\"#Functions-as-variables\" data-toc-modified-id=\"Functions-as-variables-3.1.2\"><span class=\"toc-item-num\">3.1.2 </span>Functions as variables</a></span></li><li><span><a href=\"#Lists-and-dictionaries-of-functions\" data-toc-modified-id=\"Lists-and-dictionaries-of-functions-3.1.3\"><span class=\"toc-item-num\">3.1.3 </span>Lists and dictionaries of functions</a></span></li><li><span><a href=\"#Referencing-a-function\" data-toc-modified-id=\"Referencing-a-function-3.1.4\"><span class=\"toc-item-num\">3.1.4 </span>Referencing a function</a></span></li><li><span><a href=\"#Functions-as-arguments\" data-toc-modified-id=\"Functions-as-arguments-3.1.5\"><span class=\"toc-item-num\">3.1.5 </span>Functions as arguments</a></span></li><li><span><a href=\"#Defining-a-function-inside-another-function\" data-toc-modified-id=\"Defining-a-function-inside-another-function-3.1.6\"><span class=\"toc-item-num\">3.1.6 </span>Defining a function inside another function</a></span></li></ul></li><li><span><a href=\"#Scope\" data-toc-modified-id=\"Scope-3.2\"><span class=\"toc-item-num\">3.2 </span>Scope</a></span><ul class=\"toc-item\"><li><span><a href=\"#The-global-keyword\" data-toc-modified-id=\"The-global-keyword-3.2.1\"><span class=\"toc-item-num\">3.2.1 </span>The global keyword</a></span></li><li><span><a href=\"#The-nonlocal-keyword\" data-toc-modified-id=\"The-nonlocal-keyword-3.2.2\"><span class=\"toc-item-num\">3.2.2 </span>The nonlocal keyword</a></span></li></ul></li><li><span><a href=\"#Closures\" data-toc-modified-id=\"Closures-3.3\"><span class=\"toc-item-num\">3.3 </span>Closures</a></span><ul class=\"toc-item\"><li><span><a href=\"#Attaching-nonlocal-variables-to-nested-functions\" data-toc-modified-id=\"Attaching-nonlocal-variables-to-nested-functions-3.3.1\"><span class=\"toc-item-num\">3.3.1 </span>Attaching nonlocal variables to nested functions</a></span></li><li><span><a href=\"#Closures-and-deletion\" data-toc-modified-id=\"Closures-and-deletion-3.3.2\"><span class=\"toc-item-num\">3.3.2 </span>Closures and deletion</a></span></li><li><span><a href=\"#Closures-and-overwriting\" data-toc-modified-id=\"Closures-and-overwriting-3.3.3\"><span class=\"toc-item-num\">3.3.3 </span>Closures and overwriting</a></span></li></ul></li><li><span><a href=\"#Why-does-all-of-this-matter?\" data-toc-modified-id=\"Why-does-all-of-this-matter?-3.4\"><span class=\"toc-item-num\">3.4 </span>Why does all of this matter?</a></span></li><li><span><a href=\"#Decorators\" data-toc-modified-id=\"Decorators-3.5\"><span class=\"toc-item-num\">3.5 </span>Decorators</a></span><ul class=\"toc-item\"><li><span><a href=\"#The-double_args-decorator\" data-toc-modified-id=\"The-double_args-decorator-3.5.1\"><span class=\"toc-item-num\">3.5.1 </span>The double_args decorator</a></span></li><li><span><a href=\"#Decorator-syntax\" data-toc-modified-id=\"Decorator-syntax-3.5.2\"><span class=\"toc-item-num\">3.5.2 </span>Decorator syntax</a></span></li><li><span><a href=\"#Exercise:-Defining-a-decorator\" data-toc-modified-id=\"Exercise:-Defining-a-decorator-3.5.3\"><span class=\"toc-item-num\">3.5.3 </span>Exercise: Defining a decorator</a></span></li></ul></li><li><span><a href=\"#Real-world-examples\" data-toc-modified-id=\"Real-world-examples-3.6\"><span class=\"toc-item-num\">3.6 </span>Real-world examples</a></span><ul class=\"toc-item\"><li><span><a href=\"#Time-a-function\" data-toc-modified-id=\"Time-a-function-3.6.1\"><span class=\"toc-item-num\">3.6.1 </span>Time a function</a></span></li><li><span><a href=\"#Using-timer()\" data-toc-modified-id=\"Using-timer()-3.6.2\"><span class=\"toc-item-num\">3.6.2 </span>Using timer()</a></span></li><li><span><a href=\"#When-to-use-decorators\" data-toc-modified-id=\"When-to-use-decorators-3.6.3\"><span class=\"toc-item-num\">3.6.3 </span>When to use decorators</a></span></li><li><span><a href=\"#Exercise:-Print-the-return-type\" data-toc-modified-id=\"Exercise:-Print-the-return-type-3.6.4\"><span class=\"toc-item-num\">3.6.4 </span>Exercise: Print the return type</a></span></li><li><span><a href=\"#Exercise:-Counter\" data-toc-modified-id=\"Exercise:-Counter-3.6.5\"><span class=\"toc-item-num\">3.6.5 </span>Exercise: Counter</a></span></li></ul></li><li><span><a href=\"#Decorators-and-metadata\" data-toc-modified-id=\"Decorators-and-metadata-3.7\"><span class=\"toc-item-num\">3.7 </span>Decorators and metadata</a></span><ul class=\"toc-item\"><li><span><a href=\"#fix:-The-timer-decorator\" data-toc-modified-id=\"fix:-The-timer-decorator-3.7.1\"><span class=\"toc-item-num\">3.7.1 </span>fix: The timer decorator</a></span></li><li><span><a href=\"#Access-to-the-original-function\" data-toc-modified-id=\"Access-to-the-original-function-3.7.2\"><span class=\"toc-item-num\">3.7.2 </span>Access to the original function</a></span></li></ul></li><li><span><a href=\"#Decorators-that-take-arguments\" data-toc-modified-id=\"Decorators-that-take-arguments-3.8\"><span class=\"toc-item-num\">3.8 </span>Decorators that take arguments</a></span><ul class=\"toc-item\"><li><span><a href=\"#A-decorator-factory\" data-toc-modified-id=\"A-decorator-factory-3.8.1\"><span class=\"toc-item-num\">3.8.1 </span>A decorator factory</a></span></li></ul></li><li><span><a href=\"#Timeout():-a-real-world-example\" data-toc-modified-id=\"Timeout():-a-real-world-example-3.9\"><span class=\"toc-item-num\">3.9 </span>Timeout(): a real world example</a></span><ul class=\"toc-item\"><li><span><a href=\"#Exercise:-Tag-your-functions\" data-toc-modified-id=\"Exercise:-Tag-your-functions-3.9.1\"><span class=\"toc-item-num\">3.9.1 </span>Exercise: Tag your functions</a></span></li><li><span><a href=\"#Exercise:-Check-the-return-type\" data-toc-modified-id=\"Exercise:-Check-the-return-type-3.9.2\"><span class=\"toc-item-num\">3.9.2 </span>Exercise: Check the return type</a></span></li></ul></li></ul></li></ul></div>",
"_____no_output_____"
],
[
"# Best Practices",
"_____no_output_____"
],
[
"## Docstrings",
"_____no_output_____"
],
[
"### Anatomy of a docstring",
"_____no_output_____"
]
],
[
[
"def function_name(arguments):\n \"\"\" \n Description of what the function does.\n \n Description of the arguments, if any. \n \n Description of the return value(s), if any. \n \n Description of errors raised, if any. \n \n Optional extra notes or examples of usage. \n \"\"\"",
"_____no_output_____"
]
],
[
[
"### Docstring formats\n\n- Google Style\n\n- Numpydoc\n\n- reStructuredText\n\n- EpyText",
"_____no_output_____"
],
[
"#### Google style ",
"_____no_output_____"
]
],
[
[
"def function(arg_1, arg_2=42):\n \"\"\"Description of what the function does. \n \n Args: arg_1 (str): Description of arg_1 that can break onto the next line \n if needed. \n arg_2 (int, optional): Write optional when an argument has a default \n value. \n \n Returns: \n bool: Optional description of the return value \n Extra lines are not indented. \n \n Raises: \n ValueError: Include any error types that the function intentionally\n raises. \n \n Notes: \n See https://www.datacamp.com/community/tutorials/docstrings-python \n for more info. \n \"\"\"\n",
"_____no_output_____"
]
],
[
[
"#### [Numpydoc](https://numpydoc.readthedocs.io/en/latest/format.html)",
"_____no_output_____"
]
],
[
[
"def function(arg_1, arg_2=42):\n \"\"\" Description of what the function does.\n \n Parameters \n ---------- \n arg_1 : expected type of arg_1 \n Description of arg_1. \n arg_2 : int, optional \n Write optional when an argument has a default value.\n Default=42.\n \n Returns \n ------- \n The type of the return value\n Can include a description of the return value.\n Replace \"Returns\" with \"Yields\" if this function is a generator. \n \"\"\"",
"_____no_output_____"
]
],
[
[
"### Retrieving docstrings",
"_____no_output_____"
]
],
[
[
"def the_answer():\n \"\"\"Return the answer to life, the universe, and everything.\n \n Returns: \n int\n \"\"\"\n return 42\nprint(the_answer.__doc__)",
"Return the answer to life, the universe, and everything.\n \n Returns: \n int\n \n"
],
[
"import inspect \nprint(inspect.getdoc(the_answer))",
"Return the answer to life, the universe, and everything.\n\nReturns: \n int\n"
]
],
[
[
"### Exercise 1",
"_____no_output_____"
]
],
[
[
"def count_letter(content, letter):\n \"\"\"Count the number of times `letter` appears in `content`.\n\n Args:\n content (str): The string to search.\n letter (str): The letter to search for.\n\n Returns:\n int\n\n # Add a section detailing what errors might be raised\n Raises:\n ValueError: If `letter` is not a one-character string.\n \"\"\"\n if (not isinstance(letter, str)) or len(letter) != 1:\n raise ValueError('`letter` must be a single character string.')\n return len([char for char in content if char == letter])",
"_____no_output_____"
]
],
[
[
"### Exercise 2",
"_____no_output_____"
]
],
[
[
"# Get the docstring with an attribute of count_letter()\ndocstring = count_letter.__doc__\n\nborder = '#' * 28\nprint('{}\\n{}\\n{}'.format(border, docstring, border))",
"############################\nCount the number of times `letter` appears in `content`.\n\n Args:\n content (str): The string to search.\n letter (str): The letter to search for.\n\n Returns:\n int\n\n # Add a section detailing what errors might be raised\n Raises:\n ValueError: If `letter` is not a one-character string.\n \n############################\n"
],
[
"import inspect\n\n# Get the docstring with a function from the inspect module\ndocstring = inspect.getdoc(count_letter)\n\nborder = '#' * 28\nprint('{}\\n{}\\n{}'.format(border, docstring, border))",
"############################\nCount the number of times `letter` appears in `content`.\n\nArgs:\n content (str): The string to search.\n letter (str): The letter to search for.\n\nReturns:\n int\n\n# Add a section detailing what errors might be raised\nRaises:\n ValueError: If `letter` is not a one-character string.\n############################\n"
],
[
"# Use the inspect module again to get the docstring for any function being passed to the build_tooltip() function.\n\ndef build_tooltip(function):\n \"\"\"Create a tooltip for any function that shows the \n function's docstring.\n\n Args:\n function (callable): The function we want a tooltip for.\n\n Returns:\n str\n \"\"\"\n # Use 'inspect' to get the docstring\n docstring = inspect.getdoc(function)\n border = '#' * 28\n return '{}\\n{}\\n{}'.format(border, docstring, border)\n\nprint(build_tooltip(count_letter))\nprint(build_tooltip(range))\nprint(build_tooltip(print))",
"############################\nCount the number of times `letter` appears in `content`.\n\nArgs:\n content (str): The string to search.\n letter (str): The letter to search for.\n\nReturns:\n int\n\n# Add a section detailing what errors might be raised\nRaises:\n ValueError: If `letter` is not a one-character string.\n############################\n############################\nrange(stop) -> range object\nrange(start, stop[, step]) -> range object\n\nReturn an object that produces a sequence of integers from start (inclusive)\nto stop (exclusive) by step. range(i, j) produces i, i+1, i+2, ..., j-1.\nstart defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3.\nThese are exactly the valid indices for a list of 4 elements.\nWhen step is given, it specifies the increment (or decrement).\n############################\n############################\nprint(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n\nPrints the values to a stream, or to sys.stdout by default.\nOptional keyword arguments:\nfile: a file-like object (stream); defaults to the current sys.stdout.\nsep: string inserted between values, default a space.\nend: string appended after the last value, default a newline.\nflush: whether to forcibly flush the stream.\n############################\n"
]
],
[
[
"## DRY and \"Do One Thing\"",
"_____no_output_____"
],
[
"### Don't repeat yourself (DRY)",
"_____no_output_____"
]
],
[
[
"def load_and_plot(path):\n \"\"\"Load a data set and plot the first two principal components. \n \n Args: \n path (str): The location of a CSV file. \n \n Returns: \n tuple of ndarray: (features, labels) \n \"\"\"\n # load the data\n data = pd.read_csv(path) \n y = data['label'].values \n X = data[col for col in train.columns if col != 'label'].values \n \n # plot the first two principal components\n pca = PCA(n_components=2).fit_transform(X) \n plt.scatter(pca[:,0], pca[:,1])\n \n # return loaded dat\n return X, y\n\n\ntrain_X, train_y = load_and_plot('train.csv')\nval_X, val_y = load_and_plot('validation.csv')\ntest_X, test_y = load_and_plot('test.csv')",
"_____no_output_____"
]
],
[
[
"### Do One Thing",
"_____no_output_____"
]
],
[
[
"def load_data(path):\n \"\"\"Load a data set. \n Args: \n path (str): The location of a CSV file. \n \n Returns: \n tuple of ndarray: (features, labels) \n \"\"\" \n data = pd.read_csv(path) \n y = data['labels'].values \n X = data[col for col in data.columns if col != 'labels'].values\n \n return X, y\n\n\ndef plot_data(X):\n \"\"\"Plot the first two principal components of a matrix.\n \n Args: \n X (numpy.ndarray): The data to plot. \n \"\"\" \n pca = PCA(n_components=2).fit_transform(X) \n plt.scatter(pca[:,0], pca[:,1])",
"_____no_output_____"
]
],
[
[
"## Pass by assignment",
"_____no_output_____"
],
[
"### surprising example",
"_____no_output_____"
],
[
"Immutable\n- int\n- float\n- bool\n- string\n- bytes\n- tuple\n- frozenset\n- None\n\nMutable\n- list\n- dict\n- set\n- bytearray\n- objects\n- functions\n- almost everything else!",
"_____no_output_____"
]
],
[
[
"def foo(x): \n x[0] = 99\n \nmy_list = [1, 2, 3]\nfoo(my_list)\nprint(my_list)",
"[99, 2, 3]\n"
],
[
"# intergers are Immutable\ndef bar(x):\n x = x + 90\n \nmy_var = 3\nbar(my_var)\nprint(my_var)",
"3\n"
]
],
[
[
"### Mutable default arguments are dangerous",
"_____no_output_____"
]
],
[
[
"def foo(var=[]):\n var.append(1)\n return var\n\nfoo()",
"_____no_output_____"
],
[
"foo()",
"_____no_output_____"
],
[
"def foo(var=None):\n if var is None:\n var = []\n var.append(1)\n return var\n\nfoo()",
"_____no_output_____"
],
[
"foo()",
"_____no_output_____"
]
],
[
[
"### Best practice for default arguments",
"_____no_output_____"
],
[
"Bad way to assign mutable default arguments",
"_____no_output_____"
]
],
[
[
"def add_column(values, df=pandas.DataFrame()):\n \"\"\"Add a column of `values` to a DataFrame `df`.\n The column will be named \"col_<n>\" where \"n\" is\n the numerical index of the column.\n\n Args:\n values (iterable): The values of the new column\n df (DataFrame, optional): The DataFrame to update.\n If no DataFrame is passed, one is created by default.\n\n Returns:\n DataFrame\n \"\"\"\n df['col_{}'.format(len(df.columns))] = values\n return df",
"_____no_output_____"
]
],
[
[
"Good way to assign mutable default arguments",
"_____no_output_____"
]
],
[
[
"# Use an immutable variable for the default argument \ndef better_add_column(values, df=None):\n \"\"\"Add a column of `values` to a DataFrame `df`.\n The column will be named \"col_<n>\" where \"n\" is\n the numerical index of the column.\n\n Args:\n values (iterable): The values of the new column\n df (DataFrame, optional): The DataFrame to update.\n If no DataFrame is passed, one is created by default.\n\n Returns:\n DataFrame\n \"\"\"\n # Update the function to create a default DataFrame\n if df is None:\n df = pandas.DataFrame()\n df['col_{}'.format(len(df.columns))] = values\n return df",
"_____no_output_____"
]
],
[
[
"# Context Managers",
"_____no_output_____"
],
[
"## Using context managers\n\nA context manager:\n- Sets up a context\n- Runs your code \n- Removes the context",
"_____no_output_____"
]
],
[
[
"with <context-manager>(<args>) as <variable-name>:\n # Run your code here\n # This code is running \"inside the context\"\n \n# This code runs after the context is removed",
"_____no_output_____"
]
],
[
[
"### A real-world example\n\n`open()` does three things: \n- Sets up a context by opening a file\n- Lets you run any code you want on that file\n- Removes the context by closing thele",
"_____no_output_____"
]
],
[
[
"with open('my_file.txt') as my_file:\n text = my_file.read()\n length = len(text)\n \nprint('The file is {} characters long'.format(length))",
"_____no_output_____"
]
],
[
[
"### Exercise: The speed of cats",
"_____no_output_____"
]
],
[
[
"image = get_image_from_instagram()\n\n# Time how long process_with_numpy(image) takes to run\nwith timer():\n print('Numpy version')\n process_with_numpy(image)\n\n# Time how long process_with_pytorch(image) takes to run\nwith timer():\n print('Pytorch version')\n process_with_pytorch(image)\n \nNumpy version\nProcessing..........done!\nElapsed: 1.52 seconds\nPytorch version\nProcessing..........done!\nElapsed: 0.33 seconds",
"_____no_output_____"
]
],
[
[
"## Writing context managers",
"_____no_output_____"
],
[
"Two ways to define a context manager\n- Class-based\n- **Function-based**",
"_____no_output_____"
],
[
"### How to create a context manager\n\n1. Define a function.\n2. (optional) Add any set up code your context needs.\n3. Use the \"yield\" keyword.\n4. (optional) Add any teardown code your context needs.\n5. Add the @contextlib.contextmanager decorator.",
"_____no_output_____"
]
],
[
[
"import contextlib\nfrom contextlib import contextmanager\n\[email protected]\ndef my_context():\n # Add any set up code you need\n yield\n # Add any teardown code you need",
"_____no_output_____"
]
],
[
[
"### The \"yield\" keyword",
"_____no_output_____"
]
],
[
[
"@contextlib.contextmanager\ndef my_context(): \n print('hello')\n yield 42 # The value that your contex manager yields can be assigned to a variable in the \"with\" statement by adding\"as\" variable name.\n print('goodbye')\n \nwith my_context() as foo: \n print('foo is {}'.format(foo))",
"hello\nfoo is 42\ngoodbye\n"
]
],
[
[
"### Setup and teardown",
"_____no_output_____"
]
],
[
[
"@contextlib.contextmanager\ndef database(url):\n # set up database connection \n db = postgres.connect(url)\n yield db # yields the database connection\n \n # tear down database connection \n db.disconnect()\n \n\nurl = 'http://datacamp.com/data'\nwith database(url) as my_db: \n course_list = my_db.execute('SELECT * FROM courses')",
"_____no_output_____"
]
],
[
[
"### Yielding a value or None",
"_____no_output_____"
]
],
[
[
"# context manager that changes the current working directory to a specific path and the change it back after the context block is done.\n# It does not need to return anything with \"yield\" statement\[email protected]\ndef in_dir(path): \n # save current working directory \n old_dir = os.getcwd()\n \n # switch to new working directory \n os.chdir(path)\n \n yield # not yield explicit value\n \n # change back to previous\n # working directory \n os.chdir(old_dir)\n \n \nwith in_dir('/data/project_1/'): # not yield a value\n project_files = os.listdir()",
"_____no_output_____"
]
],
[
[
"### Exercise: The timer() context manager",
"_____no_output_____"
]
],
[
[
"# Add a decorator that will make timer() a context manager\[email protected]\ndef timer():\n \"\"\"Time the execution of a context block.\n\n Yields:\n None\n \"\"\"\n start = time.time()\n # Send control back to the context block\n yield\n end = time.time()\n print('Elapsed: {:.2f}s'.format(end - start))\n\nwith timer():\n print('This should take approximately 0.25 seconds')\n time.sleep(0.25)\n \nThis should take approximately 0.25 seconds\nElapsed: 0.25s",
"_____no_output_____"
]
],
[
[
"### Exercise: A read-only open() context manager\n\nThe regular `open()` context manager:\n\n- takes a filename and a mode (`'r'` for read, `'w'` for write, or `'a'` for append)\n- opens the file for reading, writing, or appending\n- sends control back to the context, along with a reference to the file\n- waits for the context to finish\n- and then closes the file before exiting",
"_____no_output_____"
]
],
[
[
"@contextlib.contextmanager\ndef open_read_only(filename):\n \"\"\"Open a file in read-only mode.\n\n Args:\n filename (str): The location of the file to read\n\n Yields:\n file object\n \"\"\"\n read_only_file = open(filename, mode='r')\n # Yield read_only_file so it can be assigned to my_file\n yield read_only_file\n # Close read_only_file\n read_only_file.close()\n\nwith open_read_only('my_file.txt') as my_file:\n print(my_file.read())",
"_____no_output_____"
]
],
[
[
"## Advanced topics",
"_____no_output_____"
],
[
"### Nested contexts",
"_____no_output_____"
],
[
"This approach works fine until you try to copy a file that is too large to fit in memory",
"_____no_output_____"
]
],
[
[
"def copy(src, dst):\n \"\"\"Copy the contents of one file to another. \n \n Args: \n src (str): File name of the file to be copied. \n dst (str): Where to write the new file. \n \"\"\"\n \n # Open the source file and read in the contents\n with open(src) as f_src:\n contents = f_src.read()\n \n # Open the destination file and write out the contents\n with open(dst, 'w') as f_dst: \n f_dst.write(contents)",
"_____no_output_____"
]
],
[
[
"Ideal: open both files at once and copy over oneline at a time.",
"_____no_output_____"
]
],
[
[
"with open('my_file.txt') as my_file:\n for line in my_file:\n # do something",
"_____no_output_____"
],
[
"def copy(src, dst):\n \"\"\"Copy the contents of one file to another. \n \n Args: \n src (str): File name of the file to be copied. \n dst (str): Where to write the new file. \n \"\"\"\n # Open both files\n with open(src) as f_src:\n with open(dst, 'w') as f_dst:\n # Read and write each line, one at a time\n for line in f_src: \n f_dst.write(line)",
"_____no_output_____"
]
],
[
[
"### Handling errors",
"_____no_output_____"
],
[
"No handling errors",
"_____no_output_____"
]
],
[
[
"def get_printer(ip): \n p = connect_to_printer(ip)\n \n yield\n \n # This MUST be called or no one else will\n # be able to connect to the printer \n p.disconnect() \n print('disconnected from printer')\n \ndoc = {'text': 'This is my text.'}\n\nwith get_printer('10.0.34.111') as printer: \n printer.print_page(doc['txt'])\n \n\nTraceback (most recent call last): \n File \"<stdin>\", line 1, in <module> \n printer.print_page(doc['txt'])\nKeyError: 'txt'",
"_____no_output_____"
]
],
[
[
"with handling errors",
"_____no_output_____"
]
],
[
[
"try:\n # code that might raise an error\nexcept:\n # do something about the error\nfinally:\n # this code runs no matter what",
"_____no_output_____"
],
[
"def get_printer(ip): \n p = connect_to_printer(ip)\n \n try:\n yield\n finally: \n p.disconnect() \n print('disconnected from printer')\n \n \ndoc = {'text': 'This is my text.'}\n\nwith get_printer('10.0.34.111') as printer: \n printer.print_page(doc['txt'])\n \n \ndisconnected from printer\nTraceback (most recent call last): \n File \"<stdin>\", line 1, in <module> \n printer.print_page(doc['txt'])\nKeyError: 'txt'",
"_____no_output_____"
]
],
[
[
"### Context manager patterns\n\n| | |\n|---------|------------|\n| Open | Close |\n| Lock | Release |\n| Change | Reset |\n| Enter | Exit |\n| Start | Stop |\n| Setup | Teardown |\n| Connect | Disconnect |\n\n\n",
"_____no_output_____"
],
[
"### Exercise: Scraping the NASDAQ\n\nThe context manager `stock('NVDA')` will connect to the NASDAQ and return an object that you can use to get the latest price by calling its `.price()` method.\n\nYou want to connect to `stock('NVDA')` and record 10 timesteps of price data by writing it to the file `NVDA.txt`.",
"_____no_output_____"
]
],
[
[
"# Use the \"stock('NVDA')\" context manager\n# and assign the result to the variable \"nvda\"\nwith stock('NVDA') as nvda:\n # Open \"NVDA.txt\" for writing as f_out\n with open('NVDA.txt', 'w') as f_out:\n for price in range(10):\n value = nvda.price()\n print('Logging ${:.2f} for NVDA'.format(value))\n f_out.write('{:.2f}\\n'.format(value))",
"_____no_output_____"
]
],
[
[
"### Exercise: Changing the working directory",
"_____no_output_____"
]
],
[
[
"def in_dir(directory):\n \"\"\"Change current working directory to `directory`,\n allow the user to run some code, and change back.\n\n Args:\n directory (str): The path to a directory to work in.\n \"\"\"\n current_dir = os.getcwd()\n os.chdir(directory)\n\n # Add code that lets you handle errors\n try:\n yield\n # Ensure the directory is reset,\n # whether there was an error or not\n finally:\n os.chdir(current_dir)",
"_____no_output_____"
]
],
[
[
"# Decorators\n[Python 函数装饰器](https://www.runoob.com/w3cnote/python-func-decorators.html)",
"_____no_output_____"
],
[
"## Functions are objects",
"_____no_output_____"
],
[
"### Functions are just another type of object",
"_____no_output_____"
],
[
"Python objects:",
"_____no_output_____"
]
],
[
[
"def x():\n pass\nx = [1, 2, 3]\nx = {'foo': 42}\nx = pandas.DataFrame()\nx = 'This is a sentence.'\nx = 3\nx = 71.2\nimport x",
"_____no_output_____"
]
],
[
[
"### Functions as variables",
"_____no_output_____"
]
],
[
[
"def my_function(): \n print('Hello')\nx = my_function\ntype(x)",
"_____no_output_____"
],
[
"x",
"_____no_output_____"
],
[
"x()",
"Hello\n"
],
[
"PrintyMcPrintface = print\nPrintyMcPrintface('Python is awesome!')",
"Python is awesome!\n"
]
],
[
[
"### Lists and dictionaries of functions",
"_____no_output_____"
]
],
[
[
"list_of_functions = [my_function, open, print]\nlist_of_functions[2]('I am printing with an element of a list!')",
"I am printing with an element of a list!\n"
],
[
"dict_of_functions = {\n 'func1': my_function,\n 'func2': open,\n 'func3': print\n}\ndict_of_functions['func3']('I am printing with a value of a dict!')",
"I am printing with a value of a dict!\n"
]
],
[
[
"### Referencing a function",
"_____no_output_____"
]
],
[
[
"def my_function():\n return 42\n\nx = my_function\nmy_function()",
"_____no_output_____"
],
[
"my_function",
"_____no_output_____"
]
],
[
[
"### Functions as arguments",
"_____no_output_____"
]
],
[
[
"def has_docstring(func):\n \"\"\"Check to see if the function `func` has a docstring. \n \n Args: \n func (callable): A function. \n \n Returns: \n bool \n \"\"\"\n return func.__doc__ is not None",
"_____no_output_____"
],
[
"def no():\n return 42\n\ndef yes():\n \"\"\"Return the value 42 \"\"\"\n return 42\n\nhas_docstring(no)",
"_____no_output_____"
],
[
"has_docstring(yes)",
"_____no_output_____"
]
],
[
[
"### Defining a function inside another function",
"_____no_output_____"
]
],
[
[
"def foo():\n x = [3, 6, 9]\n \n def bar(y): \n print(y)\n \n for value in x:\n bar(x)",
"_____no_output_____"
],
[
"def foo(x, y):\n if x > 4 and x < 10 and y > 4 and y < 10: \n print(x * y)\n \n \n \ndef foo(x, y):\n def in_range(v):\n return v > 4 and v < 10 \n \n if in_range(x) and in_range(y): \n print(x * y)",
"_____no_output_____"
],
[
"def get_function():\n def print_me(s): \n print(s)\n \n return print_me\n\nnew_func = get_function()\nnew_func('This is a sentence.')",
"This is a sentence.\n"
]
],
[
[
"## Scope",
"_____no_output_____"
]
],
[
[
"x = 7\ny = 200\nprint(x)",
"7\n"
],
[
"def foo(): \n x = 42 \n print(x) \n print(y)\n \nfoo()",
"42\n200\n"
],
[
"print(x)",
"7\n"
]
],
[
[
"### The global keyword",
"_____no_output_____"
]
],
[
[
"x = 7\n\ndef foo(): \n x = 42 \n print(x)\n \nfoo()",
"42\n"
],
[
"print(x)",
"7\n"
],
[
"x = 7\n\ndef foo():\n global x \n x = 42 \n print(x)\n \nfoo()",
"42\n"
],
[
"print(x)",
"42\n"
]
],
[
[
"### The nonlocal keyword\nYou should try to avoid using `global` variables if possible, because it can make testing and debugging harder.\nThe `nonlocal` keyword works exactly the same as the `global` key word, but it is used whenyou are inside a nested function, and you want to update a variable that is defined inside your parent function.",
"_____no_output_____"
]
],
[
[
"def foo(): \n x = 10\n \n def bar(): \n x = 200 \n print(x) \n \n bar() \n print(x)\n \nfoo()",
"200\n10\n"
],
[
"def foo(): \n x = 10\n \n def bar():\n nonlocal x\n x = 200 \n print(x) \n \n bar() \n print(x)\n \nfoo()",
"200\n200\n"
],
[
"x = 50\n\ndef one():\n x = 10\n\ndef two():\n global x\n x = 30\n\ndef three():\n x = 100\n print(x)\n\nfor func in [one, two, three]:\n func()\n print(x)",
"50\n30\n100\n30\n"
]
],
[
[
"## Closures\n\nA closure in Python is a tuple of variables that are no longer in scope, but that a function needs in order to run.",
"_____no_output_____"
],
[
"### Attaching nonlocal variables to nested functions",
"_____no_output_____"
]
],
[
[
"def foo(): \n a = 5\n def bar():\n print(a)\n return bar\n\nfunc = foo()\n\nfunc()",
"5\n"
],
[
"type(func.__closure__)",
"_____no_output_____"
],
[
"len(func.__closure__)",
"_____no_output_____"
],
[
"func.__closure__[0].cell_contents",
"_____no_output_____"
]
],
[
[
"### Closures and deletion",
"_____no_output_____"
]
],
[
[
"x = 25 # x is defined in the gloabl scope\n\ndef foo(value):\n def bar(): \n print(value)\n return bar\n\nmy_func = foo(x)\nmy_func() # print the value x",
"25\n"
],
[
"# delete x and call my_func again, it would still print 25. \n# Because foo()'s value argument gets added to the closure attached to the new my_func function.\n# So even though x doesn't exist anymore, thevalue persists in its closure\ndel(x)\nmy_func() ",
"25\n"
],
[
"len(my_func.__closure__)",
"_____no_output_____"
],
[
"my_func.__closure__[0].cell_contents",
"_____no_output_____"
]
],
[
[
"### Closures and overwriting",
"_____no_output_____"
]
],
[
[
"# pass x into foo() and then assigned the new function to the variable x. \n# The old value of x 25 is still stored in the new function's closure. \n# even though the new function is now stores in the x variable\nx = 25\n\ndef foo(value):\n def bar(): \n print(value)\n return bar\n\nx = foo(x)\nx() ",
"25\n"
],
[
"len(x.__closure__)",
"_____no_output_____"
],
[
"x.__closure__[0].cell_contents",
"_____no_output_____"
]
],
[
[
"## Why does all of this matter?",
"_____no_output_____"
],
[
"Decorators use:\n- Functions as objects\n- Nested functions\n- Nonlocal scope\n- Closures",
"_____no_output_____"
],
[
"Nested function: A function dened inside another function",
"_____no_output_____"
]
],
[
[
"# outer function\ndef parent():\n # nested function\n def child():\n pass\n return child",
"_____no_output_____"
]
],
[
[
"Nonlocal variables: Variables dened in the parent function that are used by the child function",
"_____no_output_____"
]
],
[
[
"def parent(arg_1, arg_2):\n # From child()'s point of view,\n # `value` and `my_dict` are nonlocal variables,\n # as are `arg_1` and `arg_2`. \n value = 22 \n my_dict = {'chocolate': 'yummy'}\n \n def child(): \n print(2 * value) \n print(my_dict['chocolate']) \n print(arg_1 + arg_2)\n \n return child",
"_____no_output_____"
]
],
[
[
"Closure: Nonlocal variables attached to a returned function",
"_____no_output_____"
]
],
[
[
"def parent(arg_1, arg_2): \n value = 22 \n my_dict = {'chocolate': 'yummy'}\n def child(): \n print(2 * value) \n print(my_dict['chocolate']) \n print(arg_1 + arg_2)\n \n return child\n\nnew_function = parent(3, 4)\n\nprint([cell.cell_contents for cell in new_function.__closure__])",
"[3, 4, {'chocolate': 'yummy'}, 22]\n"
]
],
[
[
"## Decorators",
"_____no_output_____"
],
[
"### The double_args decorator",
"_____no_output_____"
]
],
[
[
"def multiply(a, b):\n return a * b\ndef double_args(func):\n def wrapper(a, b):\n # Call the passed in function, but double each argument\n return func(a * 2, b * 2)\n return wrapper\n\n# assign the new function to \"new_multiply\"\nnew_multiply = double_args(multiply)\nnew_multiply(1, 5)",
"_____no_output_____"
],
[
"multiply(1, 5)",
"_____no_output_____"
],
[
"def multiply(a, b):\n return a * b\ndef double_args(func):\n def wrapper(a, b):\n # Call the passed in function, but double each argument\n return func(a * 2, b * 2)\n return wrapper\n\n# instead of assign the new function to \"new_multiply\", we're going to overwrite the \"multiply\" varable\n# we can do this because Python stores the orignial multipy function in the new function's closure\nmultiply = double_args(multiply)\nmultiply(1, 5)",
"_____no_output_____"
]
],
[
[
"### Decorator syntax",
"_____no_output_____"
]
],
[
[
"def double_args(func):\n def wrapper(a, b):\n return func(a * 2, b * 2)\n return wrapper\n\n@double_args\ndef multiply(a, b):\n return a * b\n\nmultiply(1, 5)",
"_____no_output_____"
]
],
[
[
"### Exercise: Defining a decorator",
"_____no_output_____"
]
],
[
[
"def print_before_and_after(func):\n def wrapper(*args):\n print('Before {}'.format(func.__name__))\n # Call the function being decorated with *args\n func(*args)\n print('After {}'.format(func.__name__))\n # Return the nested function\n return wrapper\n\n@print_before_and_after\ndef multiply(a, b):\n print(a * b)\n\nmultiply(5, 10)",
"Before multiply\n50\nAfter multiply\n"
]
],
[
[
"## Real-world examples",
"_____no_output_____"
],
[
"### Time a function",
"_____no_output_____"
]
],
[
[
"import time\n\ndef timer(func):\n \"\"\"A decorator that prints how long a function took to run. \n \n Args: \n func (callable): The function being decorated. \n \n Returns: \n callable: The decorated function. \n \"\"\"\n # Define the wrapper function to return.\n def wrapper(*args, **kwargs):\n # When wrapper() is called, get the current time. \n t_start = time.time()\n # Call the decorated function and store the result. \n result = func(*args, **kwargs)\n # Get the total time it took to run, and print it. \n t_total = time.time() - t_start \n print('{} took {}s'.format(func.__name__, t_total))\n return result\n return wrapper",
"_____no_output_____"
]
],
[
[
"### Using timer()",
"_____no_output_____"
]
],
[
[
"@timer\ndef sleep_n_seconds(n): \n time.sleep(n)",
"_____no_output_____"
],
[
"sleep_n_seconds(5)",
"sleep_n_seconds took 5.001962184906006s\n"
],
[
"sleep_n_seconds(10)",
"sleep_n_seconds took 10.00467300415039s\n"
]
],
[
[
"### When to use decorators\n\nAdd common behavior to multiple functions",
"_____no_output_____"
]
],
[
[
"@timer\ndef foo():\n # do some computation\n \n@timer\ndef bar():\n # do some other computation\n \n@timer\ndef baz():\n # do something else",
"_____no_output_____"
]
],
[
[
"### Exercise: Print the return type",
"_____no_output_____"
]
],
[
[
"def print_return_type(func):\n # Define wrapper(), the decorated function\n def wrapper(*args, **kwargs):\n # Call the function being decorated\n result = func(*args, **kwargs)\n print('{}() returned type {}'.format(\n func.__name__, type(result)\n ))\n return result\n # Return the decorated function\n return wrapper\n \n@print_return_type\ndef foo(value):\n return value\n \nprint(foo(42))\nprint(foo([1, 2, 3]))\nprint(foo({'a': 42}))",
"foo() returned type <class 'int'>\n42\nfoo() returned type <class 'list'>\n[1, 2, 3]\nfoo() returned type <class 'dict'>\n{'a': 42}\n"
]
],
[
[
"### Exercise: Counter",
"_____no_output_____"
]
],
[
[
"def counter(func):\n def wrapper(*args, **kwargs):\n wrapper.count += 1\n # Call the function being decorated and return the result\n return wrapper\n wrapper.count = 0\n # Return the new decorated function\n return wrapper\n\n# Decorate foo() with the counter() decorator\n@counter\ndef foo():\n print('calling foo()')\n\n \nfoo()\nfoo()\nfoo()\n\nprint('foo() was called {} times.'.format(foo.count))",
"foo() was called 3 times.\n"
]
],
[
[
"## Decorators and metadata",
"_____no_output_____"
]
],
[
[
"def sleep_n_seconds(n=10):\n \"\"\"Pause processing for n seconds. \n \n Args: \n n (int): The number of seconds to pause for. \n \"\"\" \n time.sleep(n)\n \nprint(sleep_n_seconds.__doc__)",
"Pause processing for n seconds. \n \n Args: \n n (int): The number of seconds to pause for. \n \n"
],
[
"print(sleep_n_seconds.__name__)",
"sleep_n_seconds\n"
],
[
"print(sleep_n_seconds.__defaults__)",
"(10,)\n"
]
],
[
[
"problem: Ouput输出应该是\"a_function_requiring_decoration\"。这里的函数被warpTheFunction替代了。它重写了我们函数的名字和注释文档(docstring)。",
"_____no_output_____"
]
],
[
[
"@timer\ndef sleep_n_seconds(n=10):\n \"\"\"Pause processing for n seconds. \n \n Args: \n n (int): The number of seconds to pause for. \n \"\"\" \n time.sleep(n)\n \nprint(sleep_n_seconds.__doc__)",
"None\n"
],
[
"print(sleep_n_seconds.__name__)",
"wrapper\n"
]
],
[
[
"### fix: The timer decorator",
"_____no_output_____"
]
],
[
[
"from functools import wraps\ndef timer(func):\n \"\"\"A decorator that prints how long a function took to run. \"\"\"\n @wraps(func)\n def wrapper(*args, **kwargs):\n # When wrapper() is called, get the current time. \n t_start = time.time()\n # Call the decorated function and store the result. \n result = func(*args, **kwargs)\n # Get the total time it took to run, and print it. \n t_total = time.time() - t_start \n print('{} took {}s'.format(func.__name__, t_total))\n return result\n return wrapper",
"_____no_output_____"
],
[
"@timer\ndef sleep_n_seconds(n=10):\n \"\"\"Pause processing for n seconds. \n \n Args: \n n (int): The number of seconds to pause for. \n \"\"\" \n time.sleep(n)\n \nprint(sleep_n_seconds.__doc__)",
"Pause processing for n seconds. \n \n Args: \n n (int): The number of seconds to pause for. \n \n"
],
[
"print(sleep_n_seconds.__name__)",
"sleep_n_seconds\n"
],
[
"print(sleep_n_seconds.__defaults__)",
"None\n"
]
],
[
[
"### Access to the original function",
"_____no_output_____"
]
],
[
[
"sleep_n_seconds.__wrapped__",
"_____no_output_____"
]
],
[
[
"## Decorators that take arguments",
"_____no_output_____"
]
],
[
[
"def run_three_times(func):\n def wrapper(*args, **kwargs):\n for i in range(3): \n func(*args, **kwargs)\n return wrapper\n\n@run_three_times\ndef print_sum(a, b): \n print(a + b)\n \nprint_sum(3, 5)",
"8\n8\n8\n"
]
],
[
[
"### A decorator factory",
"_____no_output_____"
]
],
[
[
"def run_n_times(n):\n \"\"\"Define and return a decorator\"\"\"\n def decorator(func):\n def wrapper(*args, **kwargs):\n for i in range(n): \n func(*args, **kwargs)\n return wrapper\n return decorator\n \nrun_three_times = run_n_times(3)\n\n@run_three_times\ndef print_sum(a, b): \n print(a + b)\n \n@run_n_times(3)\ndef print_sum(a, b): \n print(a + b)",
"_____no_output_____"
]
],
[
[
"Using run_n_times()",
"_____no_output_____"
]
],
[
[
"@run_n_times(3)\ndef print_sum(a, b): \n print(a + b)\n\nprint_sum(3, 5)",
"8\n8\n8\n"
],
[
"@run_n_times(5)\ndef print_sum(a, b): \n print(\"Hello!\")\n\nprint_sum(3, 5)",
"Hello!\nHello!\nHello!\nHello!\nHello!\n"
]
],
[
[
"## Timeout(): a real world example",
"_____no_output_____"
]
],
[
[
"import signal\n\ndef raise_timeout(*args, **kwargs):\n raise TimeoutError()\n\n# When an \"alarm\" signal goes off, call raise_timeout()\nsignal.signal(signalnum=signal.SIGALRM, handler=raise_timeout)\n# Set off an alarm in 5 seconds\nsignal.alarm(5)\n# Cancel the alarm\nsignal.alarm(0)",
"_____no_output_____"
],
[
"def timeout_in_5s(func): \n @wraps(func)\n def wrapper(*args, **kwargs):\n # Set an alarm for 5 seconds \n signal.alarm(5)\n try:\n # Call the decorated func\n return func(*args, **kwargs)\n finally:\n # Cancel alarm \n signal.alarm(0)\n return wrapper",
"_____no_output_____"
],
[
"@timeout_in_5s\ndef foo(): \n time.sleep(10) \n print('foo!')\n \nfoo()",
"_____no_output_____"
],
[
"def timeout(n_seconds): \n def decorator(func): \n @wraps(func)\n def wrapper(*args, **kwargs):\n # Set an alarm for 5 seconds \n signal.alarm(n_seconds)\n try:\n # Call the decorated func\n return func(*args, **kwargs)\n finally:\n # Cancel alarm \n signal.alarm(0)\n return wrapper\n return decorator\n\n\n@timeout(5)\ndef foo(): \n time.sleep(10) \n print('foo!')\n \nfoo()",
"_____no_output_____"
],
[
"@timeout(20)\ndef bar(): \n time.sleep(10) \n print('bar!')\n \nbar()",
"bar!\n"
]
],
[
[
"### Exercise: Tag your functions\n\nYou've decided to write a decorator that will let you tag your functions with an arbitrary list of tags. You could use these tags for many things:\n\n- Adding information about who has worked on the function, so a user can look up who to ask if they run into trouble using it.\n- Labeling functions as \"experimental\" so that users know that the inputs and outputs might change in the future.\n- Marking any functions that you plan to remove in a future version of the code.\n- tc.",
"_____no_output_____"
]
],
[
[
"def tag(*tags):\n # Define a new decorator, named \"decorator\", to return\n def decorator(func):\n # Ensure the decorated function keeps its metadata\n @wraps(func)\n def wrapper(*args, **kwargs):\n # Call the function being decorated and return the result\n return func(*args, **kwargs)\n wrapper.tags = tags\n return wrapper\n # Return the new decorator\n return decorator\n\n@tag('test', 'this is a tag')\ndef foo():\n pass\n\nprint(foo.tags)",
"('test', 'this is a tag')\n"
]
],
[
[
"### Exercise: Check the return type",
"_____no_output_____"
]
],
[
[
"def returns_dict(func):\n # Complete the returns_dict() decorator\n def wrapper(*args, **kwargs):\n result = func(*args, **kwargs)\n assert(type(result) == dict)\n return result\n return wrapper\n\n@returns_dict\ndef foo(value):\n return value\n\ntry:\n print(foo([1,2,3]))\nexcept AssertionError:\n print('foo() did not return a dict!')",
"foo() did not return a dict!\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",
"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",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
ece90e28ce7be9bed4dfec4cb818c3e546063628 | 200,547 | ipynb | Jupyter Notebook | 03.power_consumption/08.energy-forecasting-XGBoost.ipynb | mkumar73/time-series | 6a19c69a34002981ae29b9c667486445a7a83c58 | [
"MIT"
] | 2 | 2021-10-30T19:08:19.000Z | 2021-11-17T10:21:16.000Z | 03.power_consumption/08.energy-forecasting-XGBoost.ipynb | mkumar73/time-series | 6a19c69a34002981ae29b9c667486445a7a83c58 | [
"MIT"
] | 14 | 2020-01-28T22:53:33.000Z | 2022-02-10T00:18:47.000Z | 03.power_consumption/.ipynb_checkpoints/08.energy-forecasting-XGBoost-checkpoint.ipynb | mkumar73/time-series | 6a19c69a34002981ae29b9c667486445a7a83c58 | [
"MIT"
] | 1 | 2020-05-02T02:49:33.000Z | 2020-05-02T02:49:33.000Z | 389.41165 | 124,848 | 0.928924 | [
[
[
"# Forecasting using XGBoost\n\n- One-step recursive forecasting",
"_____no_output_____"
]
],
[
[
"import pandas as pd\nimport numpy as np\nimport os\n\nimport matplotlib.pyplot as plt\nimport seaborn as sns\n%matplotlib inline\n\n\n# accuracy measures and data spliting\nfrom sklearn.metrics import mean_squared_error\nfrom sklearn.metrics import mean_absolute_error\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.model_selection import GridSearchCV\n\n# deep learning libraries\nimport xgboost as xgb\nimport graphviz",
"_____no_output_____"
],
[
"plt.style.use('seaborn')\nplt.rcParams['figure.figsize'] = 15, 7",
"_____no_output_____"
]
],
[
[
"## 1. Data import",
"_____no_output_____"
]
],
[
[
"DATADIR = '../data/power-consumption/'\nMODELDIR = '../checkpoints/power/xgb/model/'",
"_____no_output_____"
],
[
"# directory for saving model \nif os.path.exists(MODELDIR):\n pass\nelse:\n os.makedirs(MODELDIR)",
"_____no_output_____"
],
[
"data = pd.read_csv(os.path.join(DATADIR, 'processed_data.csv'))",
"_____no_output_____"
],
[
"data.head()",
"_____no_output_____"
]
],
[
[
"## 2. Train test split",
"_____no_output_____"
]
],
[
[
"y = data[['Global_active_power']].copy()\n\n# let xgboost decide the most important features\nX = data.drop(columns=['date', 'Global_active_power', 'Median_active_power', 'Lagged_active_power', 'median_residual'], axis=1)\n\n# last 40 weeks data for testing\ntest_size = np.int16(7*1)\ntrain_size = X.shape[0] - test_size\n\n\nX_train, X_test = X.loc[:train_size-1, :], X.loc[train_size:, :]\ny_train, y_test = y.loc[:train_size-1, :], y.loc[train_size:, :]\n\nX_train.shape, X_test.shape, y_train.shape, y_test.shape",
"_____no_output_____"
]
],
[
[
"## 5. Model fitting",
"_____no_output_____"
]
],
[
[
"params = {'objective' :'reg:linear', \n 'colsample_bytree' : 1, \n 'learning_rate' : 0.1,\n 'max_depth': 5,\n 'alpha' : 10, \n 'n_estimators' : 200}",
"_____no_output_____"
],
[
"X_train_v = X_train.values\nX_test_v = X_test.values\ny_train_v = y_train.values\ny_test_v = y_test.values",
"_____no_output_____"
],
[
"def xgb_model(X_train_v, y_train_v, params=dict()):\n model = xgb.XGBRegressor(**params)\n \n model.fit(X_train_v, y_train_v, verbose=False)\n y_train_pred = model.predict(X_train_v)\n \n onestep_pred = []\n for i in range(X_test.shape[0]):\n model.fit(X_train_v, y_train_v, verbose=False)\n\n pred = model.predict(X_test_v[i, :].reshape(1, -1))\n onestep_pred.append(pred)\n\n tempX = np.vstack((X_train_v, X_test_v[i, :])) \n X_train_v = tempX.copy()\n\n arr_pred = np.array([pred]).reshape(-1, 1)\n tempY = np.vstack((y_train_v, arr_pred))\n y_train_v = tempY.copy()\n \n y_test_pred = np.array(onestep_pred)\n \n return y_train_pred, y_test_pred",
"_____no_output_____"
],
[
"y_train_pred, y_test_pred = xgb_model(X_train_v, y_train_v, params=params)",
"_____no_output_____"
]
],
[
[
"## 6. Model evaluation",
"_____no_output_____"
]
],
[
[
"def model_evaluation(y_train, y_test, y_train_pred, y_test_pred):\n\n # MAE and NRMSE calculation\n train_rmse = np.sqrt(mean_squared_error(y_train, y_train_pred))\n train_mae = np.round(mean_absolute_error(y_train, y_train_pred), 3)\n train_nrmse = np.round(train_rmse/np.std(y_train), 3)\n\n test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred))\n test_mae = np.round(mean_absolute_error(y_test, y_test_pred), 3)\n test_nrmse = np.round(test_rmse/np.std(y_test), 3)\n\n print(f'Training MAE: {train_mae}')\n print(f'Trainig NRMSE: {train_nrmse}')\n\n print(f'Test MAE: {test_mae}')\n print(f'Test NRMSE: {test_nrmse}')\n ",
"_____no_output_____"
],
[
"model_evaluation(y_train_v, y_test_v, y_train_pred, y_test_pred)",
"Training MAE: 4.162\nTrainig NRMSE: 0.009\nTest MAE: 8.907\nTest NRMSE: 0.026\n"
],
[
"plt.plot(y_train_v, label='actual')\nplt.plot(y_train_pred, label='predicted')\nplt.ylabel('kWatt')\nplt.xlabel('index')\nplt.title('Actual vs Predicted on Training data', fontsize=14)\nplt.legend()\nplt.tight_layout()\nplt.show()",
"_____no_output_____"
],
[
"plt.plot(y_test_v, label='actual')\nplt.plot(y_test_pred, label='predicted')\nplt.ylabel('kWatt')\nplt.xlabel('index')\nplt.title('Actual vs predicted on test data using recursive XGBoost', fontsize=14)\nplt.legend()\nplt.tight_layout()\nplt.show()",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
]
] |
ece922f56c123945651af9e89857c0eda154f5f3 | 11,587 | ipynb | Jupyter Notebook | 02_introduccion_a_flask.ipynb | PythonistaMX/py231 | 734f5972948f7d23d581ec54ee7af581eca651ce | [
"MIT"
] | 3 | 2020-05-05T23:38:45.000Z | 2021-11-05T01:03:38.000Z | 02_introduccion_a_flask.ipynb | PythonistaMX/py221 | 734f5972948f7d23d581ec54ee7af581eca651ce | [
"MIT"
] | null | null | null | 02_introduccion_a_flask.ipynb | PythonistaMX/py221 | 734f5972948f7d23d581ec54ee7af581eca651ce | [
"MIT"
] | 4 | 2020-10-20T01:15:23.000Z | 2022-02-08T02:27:35.000Z | 30.412073 | 405 | 0.579184 | [
[
[
"[](https://www.pythonista.io)",
"_____no_output_____"
],
[
"# Introducción a *Flask*.",
"_____no_output_____"
],
[
"[*Flask*](https://flask.palletsprojects.com) es conocido como un \"*microframework*\". Es decir, que a diferencia de proyectos como *Django* que viene \"con las pilas incluidas\", *Flask* solamente contiene funcionalidades básicas tales como:\n\n* Un servidor de aplicaciones basado en la biblioteca [*Werkzeug*](https://werkzeug.palletsprojects.com/).\n* Soporte de Plantillas por medio de [*Jinja*](https://jinja.palletsprojects.com).\n* Una herramienta de depuración.\n* Soporte para pruebas unitarias.\n* Soporte para cookies seguras.\n* Soporte para desarrollo de instrucciones por medio de la interfaz de línea de comandos (*CLI*) mediante [*Click*](https://click.palletsprojects.com/).",
"_____no_output_____"
],
[
"## Las extensiones de *Flask*.\n\nAún cuando la instalación básica de *Flask* contiene componentes mínimos, el proyecto cuenta con un amplio catáĺogo de extensiones disponibles en la siguiente liga: \n\nhttps://flask.palletsprojects.com/en/2.0.x/extensions/",
"_____no_output_____"
],
[
"## Instalación del paquete ```flask```.\n\nEl paquete ```flask``` se puede encontrar dentro del catalogo de [*pypi*](https://pypi.org/project/Flask/) y puede ser instalado mediante ```pip```.",
"_____no_output_____"
]
],
[
[
"!pip install flask",
"_____no_output_____"
]
],
[
[
"## La clase ```flask.Flask```.\n\nLa clase ```flask.Flask``` es el componente principal del framework. Los objetos instanciados a partir de esta clase realizarán todas las funciones del servidor de aplicaciones.\n\nEl único parámetro requerido obligatoriamente al instanciar un objeto de tipo ```Flask``` es el nombre de la aplicación, el cual de principio corresponde al objeto asignado al nombre del entorno global ```__name__```.\n\nSolamente si se piensa en utilizar un objeto de tipo ```Flask``` dentro de un paquete, el nombre deber de ser cambiado por el nombre del paquete.\n\n**Sintaxis:**\n\n``` python\n<nombre> = flask.Flask(<nombre de la aplicación>)\n```\n\n**Nota:** aún cuando puede asignársele cualquier nombre, se utiliza el nombre ```app``` por convención. En adelante se usará dicha convención para hacer referencia a un objeto instanciado de la clase ```flask.Flask```. ",
"_____no_output_____"
],
[
"**Ejemplo:**\n\nLas siguientes líneas de código asigna el nombre ```app``` al objeto instanciado de la clase ```Flask```, ingresando el nombre ```_name__``` como argumento.",
"_____no_output_____"
]
],
[
[
"from flask import Flask\napp = Flask(__name__)",
"_____no_output_____"
],
[
"app",
"_____no_output_____"
]
],
[
[
"## El atributo ```app.config```. ",
"_____no_output_____"
],
[
"El atributo ```app.config``` es un objeto instanciado de una subclase de ```dict``` que sirve como el recurso usado para consultar, añadir o modificar los parámetros de configuración de la aplicación, incluyendo aquellas que son utulizadas por las extensiones de *Flask*.\n\nLa documentación de ```app.config``` puede ser consultada en:\n\nhttps://flask.palletsprojects.com/en/2.0.x/config/",
"_____no_output_____"
]
],
[
[
"app.config",
"_____no_output_____"
]
],
[
[
"### Opciones comunes de ```app.config```.\n\n* ```app.config['ENV']```, la cual define el entorno en el que se ejecutará la aplicación y que corresponde a:\n * ```'production'``` para entornos en producción.\n * ```'development'``` para entornos de desarrollo.\n* ```app.config['DEBUG']```, la cual indica si la aplicación se ejecutará en modo de depuración en caso de que sea ```True```.\n* ```app.config['TESTING']```, la cual indica si la aplicación está corriendo pruebas, en caso de que sea ```True```. \n* ```app.config['SECRET_KEY']```, la cual define la clave base a partir de la cual se construirán los *hash* de cifrado. ",
"_____no_output_____"
],
[
"**Ejemplos:**",
"_____no_output_____"
]
],
[
[
"app.config['ENV']",
"_____no_output_____"
],
[
"app.config['DEBUG']",
"_____no_output_____"
],
[
"app.config['TESTING']",
"_____no_output_____"
],
[
"app.config['SECRET_KEY']",
"_____no_output_____"
]
],
[
[
"### Métodos para la carga de configuraciones de ```app.config``` .\n\nAlgunos valores de configuración de ```app.config``` pueden contener contraseñas o datos sensibles que por seguridad no deben de ser incluidos en el código de la aplicación.\n\nEs por ello que los siguientes métodos permiten cargar los parámetros de configuración de ```app.config``` desde un archivo u objeto.\n\n```\n<método>(<ruta>)\n```\nDonde: \n* <método> es uno de los siguientes métodos:\n * ```app.config.from_file()```\n * ```app.config.from_json()```\n * ```app.config.from_pyfile()```",
"_____no_output_____"
],
[
"**Ejemplo:**",
"_____no_output_____"
],
[
"* La siguiente celda importará la configuración del archivo ```settings.cfg```. ",
"_____no_output_____"
]
],
[
[
"app.config.from_pyfile('settings.cfg')",
"_____no_output_____"
],
[
"%pycat settings.cfg",
"_____no_output_____"
],
[
"app.config['SECRET_KEY']",
"_____no_output_____"
]
],
[
[
"## Rutas y funciones de vista.\n\nCuando un cliente realiza una petición al servidor de aplicaciones de *Flask*, ésta debe de corresponder a una ruta válida capaz de gestionar dicha petición. De lo contrario, el servidor de *Flask* regresará un estado ```404```.\n\n**Nota:** las respuestas que envía el servidor de aplicaciones de *Flask* son documentos *HTML* por defecto.",
"_____no_output_____"
],
[
"## El método ```app.route()```.\n\n \nEl método ```app.route()``` es una función de orden superior que al ser usada como decorador, permite ligar a una ruta con una función.\n\n\n```\[email protected](<regla de url>, methods=<métodos>)\ndef <vista>():\n ...\n ...\n```\n\nDonde:\n\n* ```<regla de url>``` es un objeto ```str``` que define la ruta a la que se asociará una función de vista. \n* ```<métodos>``` es un objeto de tipo ```list``` que contiene los nombres en formato ```str``` de los métodos *HTTP*. El valor por defecto es ```[\"GET\"]```.\n* ```<función de vista>``` es la definición de una función cuyo resultado será enviado al cliente quen realice una petición a la ruta indicada.",
"_____no_output_____"
],
[
"**Ejemplo:**",
"_____no_output_____"
],
[
"La siguiente celda creará una regla de *URL* para el directorio raíz del servidor de aplicaciones, la cual enviará como mensaje de respuesta un documento *HTML*, el cual contendrá el texto ```<p>Hola, Mundo.</p>```",
"_____no_output_____"
]
],
[
[
"@app.route('/')\ndef inicio():\n return '<p>Hola, Mundo.</p>'",
"_____no_output_____"
]
],
[
[
"## El método ```app.run()```.\n\nEl método ```app.run()``` es el encargado de levantar el servidor web. Es posible ingresar algunos parámetros iniciales tales como:\n\n\n```\napp.run(<parámetros>)\n```\n\n* El parámetro ```host``` al cual se le asignaría un objeto de tipo ```str``` que definiría el rango de las direcciones *IP* que puede escuchar. El valor inicial es ```'localhost'```, pero se puede especificar el rango de direcciones *IP* al que se desee atender. Por ejemplo, ```'0.0.0.0'``` indica que el servidor de aplicaciones escuchará a todas las direcciones *IP*.\n* El parámetro ```port``` corresponde a un número entero cuyo valor predetermiando es ```5000``` y defiene el puerto al que el servicio será asignado.\n* El parámetro ```debug``` permite a *Flask* entrar en modo de depuración y su valor es un boolenado que por defecto es ```False```.\n",
"_____no_output_____"
],
[
"**Ejemplo:**",
"_____no_output_____"
]
],
[
[
"app.run(host=\"0.0.0.0\", port=5000)",
"_____no_output_____"
]
],
[
[
"<p style=\"text-align: center\"><a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\"><img alt=\"Licencia Creative Commons\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by/4.0/80x15.png\" /></a><br />Esta obra está bajo una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by/4.0/\">Licencia Creative Commons Atribución 4.0 Internacional</a>.</p>\n<p style=\"text-align: center\">© José Luis Chiquete Valdivieso. 2022.</p>",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
]
] |
ece9235e59621c92d2aa50147982204f71e534a3 | 812,222 | ipynb | Jupyter Notebook | WordClouds/Plot_Wordclouds.ipynb | ashishsarout/AI_for_social_good | d9e04aae58a8e67e52d17a15375f55d1af1e8e88 | [
"MIT"
] | 6 | 2021-08-06T14:15:20.000Z | 2022-03-19T09:58:15.000Z | WordClouds/Plot_Wordclouds.ipynb | Zubrah/AI_For_Social_Good | da80066b53545893d85b152d0fe3bef7beea2684 | [
"MIT"
] | null | null | null | WordClouds/Plot_Wordclouds.ipynb | Zubrah/AI_For_Social_Good | da80066b53545893d85b152d0fe3bef7beea2684 | [
"MIT"
] | 5 | 2021-07-26T07:25:07.000Z | 2022-03-29T23:14:55.000Z | 4,186.71134 | 404,084 | 0.964443 | [
[
[
"import pandas as pd \nfrom wordcloud import WordCloud\nimport matplotlib.pyplot as plt\nfrom nltk import FreqDist\nfrom nltk import ngrams\nimport numpy as np\nimport matplotlib as mpl\n%matplotlib inline",
"_____no_output_____"
],
[
"def generate_frequency(text_list):\n fdist = FreqDist()\n for i in text_list:\n words = i.split(' ')\n words = [word for word in words if word != '']\n words = ngrams(words,1)\n for x in words:\n fdist[x[0]]+=1\n return fdist",
"_____no_output_____"
],
[
"df = pd.read_csv('../Dataset/cleanedRedditSuicide.csv')",
"_____no_output_____"
],
[
"fdist = generate_frequency(df['cleaned'])\ntop_words = fdist.most_common(n=150)",
"_____no_output_____"
],
[
"word_dict = {}\nfor i in range(len(top_words)):\n word_dict[top_words[i][0]] = top_words[i][1]",
"_____no_output_____"
],
[
"cmap = plt.cm.Blues(np.linspace(0,1,20)) \ncmap = mpl.colors.ListedColormap(cmap[-9:,:-1]) ",
"_____no_output_____"
],
[
"\nwordcloud = WordCloud(background_color=\"white\",max_font_size=40,colormap=cmap).generate_from_frequencies(word_dict)\n\nplt.figure(figsize = (14, 8)) \nplt.imshow(wordcloud, interpolation='bilinear')\nplt.axis(\"off\")\nplt.show()",
"_____no_output_____"
],
[
"cmap = plt.cm.Oranges(np.linspace(0,1,20)) \ncmap = mpl.colors.ListedColormap(cmap[-9:,:-1]) ",
"_____no_output_____"
],
[
"df = pd.read_csv('../Dataset/cleanedTwitterSuicide.csv')",
"_____no_output_____"
],
[
"fdist = generate_frequency(df['cleaned'])\ntop_words = fdist.most_common(n=150)",
"_____no_output_____"
],
[
"word_dict = {}\nfor i in range(len(top_words)):\n word_dict[top_words[i][0]] = top_words[i][1]",
"_____no_output_____"
],
[
"wordcloud = WordCloud(background_color=\"white\",max_font_size=40, colormap=cmap).generate_from_frequencies(word_dict)\n\nplt.figure(figsize = (14, 8)) \nplt.imshow(wordcloud, interpolation='bilinear')\nplt.axis(\"off\")\nplt.show()\n",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ece929c4443344a39c52fced3a061e6587738b44 | 1,606 | ipynb | Jupyter Notebook | 剑指offer/.ipynb_checkpoints/#59-checkpoint.ipynb | yang-233/algorithm-notebook | f225933bc61e01f911c5280867741d46d6542211 | [
"MIT"
] | null | null | null | 剑指offer/.ipynb_checkpoints/#59-checkpoint.ipynb | yang-233/algorithm-notebook | f225933bc61e01f911c5280867741d46d6542211 | [
"MIT"
] | null | null | null | 剑指offer/.ipynb_checkpoints/#59-checkpoint.ipynb | yang-233/algorithm-notebook | f225933bc61e01f911c5280867741d46d6542211 | [
"MIT"
] | null | null | null | 22.305556 | 78 | 0.433998 | [
[
[
"from typing import *\nclass Solution:\n def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:\n que, max_que, res = [], [], []\n\n for i in nums:\n que.append(i)\n while len(max_que) > 0 and max_que[-1] < i:\n max_que.pop()\n max_que.append(i)\n\n if len(que) == k:\n res.append(max_que[0])\n v = que.pop(0)\n if max_que[0] == v:\n max_que.pop(0)\n\n if not res and max_que: # 如果k > n\n res.append(max_que[0])\n\n return res\n \n",
"_____no_output_____"
],
[
"# 实际上就是那个可以获得最大值的队列的应用",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code"
]
] |
ece92c49a4284e5a42bbf55e97f32b81979a3094 | 5,455 | ipynb | Jupyter Notebook | NotebookExamples/polyglot/d3js.ipynb | nstone1012/interactive | 6f996e0ff070c4d6b5f3fcb10a0bb7bc760c8252 | [
"MIT"
] | null | null | null | NotebookExamples/polyglot/d3js.ipynb | nstone1012/interactive | 6f996e0ff070c4d6b5f3fcb10a0bb7bc760c8252 | [
"MIT"
] | null | null | null | NotebookExamples/polyglot/d3js.ipynb | nstone1012/interactive | 6f996e0ff070c4d6b5f3fcb10a0bb7bc760c8252 | [
"MIT"
] | null | null | null | 36.125828 | 305 | 0.448579 | [
[
[
"# Visualizing data using d3js\n\n**This is a work in progress.** It doesn't work yet in [Binder](https://mybinder.org/v2/gh/dotnet/interactive/master?urlpath=lab) because it relies on HTTP communication between the kernel and the Jupyter frontend.\n\nThis notebooks uses directly [d3.js](https://d3js.org/) library to perform custom data visualisation.",
"_____no_output_____"
]
],
[
[
"var rnd = new Random();\nvar a = Enumerable.Range(1,rnd.Next(4,12)).Select( t => rnd.Next(t, t*10)).ToArray();",
"_____no_output_____"
]
],
[
[
"Using [RequireJS](https://requirejs.org/) we import [d3.js](https://d3js.org/). We setup the rendering code, some SVG filter inspiredy by [Visual Cinnamon](https://www.visualcinnamon.com/) article on [gooey effect](https://www.visualcinnamon.com/2016/06/fun-data-visualizations-svg-gooey-effect).\n\nUsing `interactive.csharp.getVariable` we fetch the variable `a` value.",
"_____no_output_____"
]
],
[
[
"#!html\n<svg id=\"dataPlot\" width=\"100%\"></svg>\n<script>\n dtree_require = require.config({\n paths: {\n d3: \"https://d3js.org/d3.v5.min\"\n }\n });\n dtree_require([\"d3\"], function (d3) {\n let svg = d3.\n select(\"svg#dataPlot\");\n svg.selectAll(\"defs\").remove();\n svg.selectAll(\"g\").remove();\n \n let defs = svg.append(\"defs\");\n\n let filter = defs.append(\"filter\").attr(\"id\", \"gooeyCodeFilter\");\n\n filter.append(\"feGaussianBlur\")\n .attr(\"in\", \"SourceGraphic\")\n .attr(\"stdDeviation\", \"10\")\n .attr(\"color-interpolation-filters\", \"sRGB\")\n .attr(\"result\", \"blur\");\n\n filter.append(\"feColorMatrix\")\n .attr(\"in\", \"blur\")\n .attr(\"mode\", \"matrix\")\n .attr(\"values\", \"1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 19 -9\")\n .attr(\"result\", \"gooey\");\n\n let container = d3\n .select(\"svg#dataPlot\")\n .append(\"g\")\n .style(\"filter\", \"url(#gooeyCodeFilter)\");\n\n if (typeof (interval) !== 'undefined') {\n clearInterval(interval);\n }\n updateD3Rendering = () => interactive.csharp.getVariable(\"a\")\n .then(data => {\n container\n .selectAll(\".points\")\n .data(data, (d,i) => i)\n .join(\n enter => enter.append(\"circle\")\n .attr(\"class\", \"points\")\n .attr(\"cy\", 80)\n .attr(\"cx\", (d, i) => ((i + 1) * 60))\n .transition()\n .duration(2000)\n .style(\"fill\", d => d3.interpolateTurbo(d / 80))\n .ease(d3.easeElastic.period(0.1))\n .attr(\"r\", d => Math.max(0,d)),\n update => update\n .transition()\n .duration(2000)\n .ease(d3.easeElastic.period(0.1))\n .style(\"fill\", d => d3.interpolateTurbo(d / 80))\n .attr(\"r\", d => Math.max(0,d)),\n exit => exit.remove());\n });\n interval = setInterval(() => updateD3Rendering(), 1000);\n });\n</script>",
"_____no_output_____"
]
],
[
[
"Notice the `setInterval` call near the end of the previous cell. This rechecks the data in the kernel and updates the plot.\n\nBack on the kernel, we can now update the data so that the kernel can see it.\n\nYes, this is a contrived example, and we're planning to support true streaming data, but it's a start.",
"_____no_output_____"
]
],
[
[
"for(var i = 0; i < 10; i++){\n await Task.Delay(2000);\n var limit = rnd.Next(4,12);\n a = Enumerable.Range(1,limit).Select( t => rnd.Next(15, 80)).ToArray();\n}",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
ece92e612bd669e75bd7076d158b93c3f9c86c53 | 82,775 | ipynb | Jupyter Notebook | examples/conll-2003.ipynb | sloth2012/ner-bert | 52097650ffad0d2ee964d4bc8a64a901d6045cdd | [
"MIT"
] | 1 | 2019-09-24T04:23:50.000Z | 2019-09-24T04:23:50.000Z | examples/conll-2003.ipynb | 672425265/ner-bert | 730cd1700513dbd51dc9736290db36855f27a3e0 | [
"MIT"
] | null | null | null | examples/conll-2003.ipynb | 672425265/ner-bert | 730cd1700513dbd51dc9736290db36855f27a3e0 | [
"MIT"
] | 1 | 2019-11-07T07:48:08.000Z | 2019-11-07T07:48:08.000Z | 22.305309 | 154 | 0.467786 | [
[
[
"### Conll 2003 evaluation\n\nData downloaded from [here](https://github.com/kyzhouhzau/BERT-NER/tree/master/NERdata).",
"_____no_output_____"
]
],
[
[
"%reload_ext autoreload\n%autoreload 2\n%matplotlib inline\n\nimport pandas as pd\nimport warnings\nimport os\nimport sys\n\nsys.path.append(\"../\")\n\nwarnings.filterwarnings(\"ignore\")",
"_____no_output_____"
],
[
"data_path = \"/datadrive/conll-2003/\"\n\ntrain_path = data_path + \"train.txt\"\ndev_path = data_path + \"dev.txt\"\ntest_path = data_path + \"test.txt\"",
"_____no_output_____"
]
],
[
[
"### 0. Prc data for csv format",
"_____no_output_____"
]
],
[
[
"import codecs\n\n\ndef read_data(input_file):\n \"\"\"Reads a BIO data.\"\"\"\n with codecs.open(input_file, \"r\", encoding=\"utf-8\") as f:\n lines = []\n words = []\n labels = []\n for line in f:\n contends = line.strip()\n word = line.strip().split(' ')[0]\n label = line.strip().split(' ')[-1]\n if contends.startswith(\"-DOCSTART-\"):\n words.append('')\n continue\n \n if len(contends) == 0 and not len(words):\n words.append(\"\")\n \n if len(contends) == 0 and words[-1] == '.':\n l = ' '.join([label for label in labels if len(label) > 0])\n w = ' '.join([word for word in words if len(word) > 0])\n lines.append([l, w])\n words = []\n labels = []\n continue\n words.append(word)\n labels.append(label.replace(\"-\", \"_\"))\n return lines\n",
"_____no_output_____"
],
[
"train_f = read_data(train_path)\ndev_f = read_data(dev_path)\ntest_f = read_data(test_path)",
"_____no_output_____"
],
[
"[l for l in train_f]",
"_____no_output_____"
],
[
"len(train_f), len(dev_f), len(test_f)",
"_____no_output_____"
],
[
"train_f[0]",
"_____no_output_____"
],
[
"import pandas as pd",
"_____no_output_____"
],
[
"train_df = pd.DataFrame(train_f, columns=[\"0\", \"1\"])\ntrain_df.to_csv(data_path + \"train.csv\", index=False)",
"_____no_output_____"
],
[
"valid_df = pd.DataFrame(dev_f, columns=[\"0\", \"1\"])\nvalid_df.to_csv(data_path + \"valid.csv\", index=False)",
"_____no_output_____"
],
[
"test_df = pd.DataFrame(test_f, columns=[\"0\", \"1\"])\ntest_df.to_csv(data_path + \"test.csv\", index=False)",
"_____no_output_____"
]
],
[
[
"### 1. Create data loaders",
"_____no_output_____"
]
],
[
[
"import os\n\ndata_path = \"/datadrive/conll-2003/\"\ntrain_path = data_path + \"train.csv\"\nvalid_path = data_path + \"valid.csv\"\ntest_path = data_path + \"test.csv\"\n\nmodel_dir = \" /datadrive/models/multi_cased_L-12_H-768_A-12/\"\ninit_checkpoint_pt = os.path.join(\"/datadrive/models/multi_cased_L-12_H-768_A-12/\", \"pytorch_model.bin\")\nbert_config_file = os.path.join(\"/datadrive/bert/multi_cased_L-12_H-768_A-12/\", \"bert_config.json\")\nvocab_file = os.path.join(\"/datadrive/bert/multi_cased_L-12_H-768_A-12/\", \"vocab.txt\")",
"_____no_output_____"
],
[
"import torch\ntorch.cuda.set_device(0)\ntorch.cuda.is_available(), torch.cuda.current_device()",
"_____no_output_____"
],
[
"from modules import BertNerData as NerData",
"INFO:summarizer.preprocessing.cleaner:'pattern' package not found; tag filters are not available for English\n"
],
[
"data = NerData.create(train_path, valid_path, vocab_file)",
"_____no_output_____"
],
[
"len(data.train_dl.dataset), len(data.valid_dl.dataset)",
"_____no_output_____"
],
[
"print(data.id2label)",
"['<pad>', '[CLS]', '[SEP]', 'B_ORG', 'B_O', 'I_O', 'B_MISC', 'B_PER', 'I_PER', 'B_LOC', 'I_LOC', 'I_ORG', 'I_MISC']\n"
],
[
"sup_labels = ['B_ORG', 'B_MISC', 'B_PER', 'I_PER', 'B_LOC', 'I_LOC', 'I_ORG', 'I_MISC']",
"_____no_output_____"
],
[
"max([len(f.labels_ids) for f in data.train_dl.dataset])",
"_____no_output_____"
]
],
[
[
"### 2. Create model",
"_____no_output_____"
]
],
[
[
"from modules.models.bert_models import BertBiLSTMAttnCRF",
"_____no_output_____"
],
[
"model = BertBiLSTMAttnCRF.create(len(data.label2idx), bert_config_file, init_checkpoint_pt, enc_hidden_dim=256)",
"_____no_output_____"
],
[
"model.get_n_trainable_params()",
"_____no_output_____"
]
],
[
[
"#### TODO: fix bug with len",
"_____no_output_____"
],
[
"### 3. Create Learner",
"_____no_output_____"
]
],
[
[
"from modules import NerLearner",
"_____no_output_____"
],
[
"num_epochs = 100\nlearner = NerLearner(model, data,\n best_model_path=\"/datadrive/models/conll-2003/bilstm_attn_cased.cpt\",\n lr=0.001, clip=1.0, sup_labels=data.id2label[5:],\n t_total=num_epochs * len(data.train_dl))",
"_____no_output_____"
]
],
[
[
"### 4. Start learning",
"_____no_output_____"
]
],
[
[
"learner.fit(num_epochs, target_metric='f1')",
"_____no_output_____"
]
],
[
[
"### 5. Evaluate dev set",
"_____no_output_____"
]
],
[
[
"from modules.data.bert_data import get_bert_data_loader_for_predict\ndl = get_bert_data_loader_for_predict(data_path + \"valid.csv\", learner)",
"_____no_output_____"
],
[
"learner.load_model()",
"_____no_output_____"
],
[
"preds = learner.predict(dl)",
"_____no_output_____"
]
],
[
[
"IOB precision",
"_____no_output_____"
]
],
[
[
"from modules.train.train import validate_step\nprint(validate_step(learner.data.valid_dl, learner.model, learner.data.id2label, learner.sup_labels))",
"_____no_output_____"
]
],
[
[
"Span precision",
"_____no_output_____"
]
],
[
[
"from modules.utils.plot_metrics import get_bert_span_report\nclf_report = get_bert_span_report(dl, preds, [])\nprint(clf_report)",
" precision recall f1-score support\n\n MISC 0.902 0.886 0.894 905\n LOC 0.925 0.914 0.920 1669\n O 0.992 0.992 0.992 41803\n ORG 0.849 0.875 0.862 1282\n PER 0.936 0.950 0.943 1686\n\n micro avg 0.982 0.982 0.982 47345\n macro avg 0.921 0.923 0.922 47345\nweighted avg 0.982 0.982 0.982 47345\n\n"
]
],
[
[
"### 6. Evaluate test set",
"_____no_output_____"
]
],
[
[
"from modules.data.bert_data import get_bert_data_loader_for_predict\ndl = get_bert_data_loader_for_predict(data_path + \"test.csv\", learner)",
"_____no_output_____"
],
[
"preds = learner.predict(dl)",
"_____no_output_____"
],
[
"data = NerData.create(train_path, data_path + \"test.csv\", vocab_file)",
"_____no_output_____"
]
],
[
[
"IOB precision",
"_____no_output_____"
]
],
[
[
"from modules.train.train import validate_step\nprint(validate_step(data.valid_dl, learner.model, learner.data.id2label, learner.sup_labels))",
"_____no_output_____"
]
],
[
[
"Span precision",
"_____no_output_____"
]
],
[
[
"from modules.utils.plot_metrics import get_bert_span_report\nclf_report = get_bert_span_report(dl, preds, [])\nprint(clf_report)",
" precision recall f1-score support\n\n MISC 0.759 0.794 0.776 688\n LOC 0.865 0.852 0.859 1570\n O 0.979 0.977 0.978 37693\n ORG 0.635 0.665 0.650 1533\n PER 0.878 0.879 0.878 1566\n\n micro avg 0.955 0.955 0.955 43050\n macro avg 0.823 0.833 0.828 43050\nweighted avg 0.955 0.955 0.955 43050\n\n"
]
],
[
[
"### 7. Get mean and stdv on 10 runs",
"_____no_output_____"
]
],
[
[
"from modules.utils.plot_metrics import *\nfrom modules import NerLearner\n\n\nnum_runs = 10\nbest_reports = []\nnum_epochs = 100\nfor i in range(num_runs):\n model = BertBiLSTMAttnCRF.create(len(data.label2idx), bert_config_file, init_checkpoint_pt, enc_hidden_dim=256)\n best_model_path = \"/datadrive/models/conll-2003/exp_{}_attn_cased.cpt\".format(i)\n learner = NerLearner(model, data,\n best_model_path=best_model_path, verbose=False,\n lr=0.001, clip=5.0, sup_labels=data.id2label[5:], t_total=num_epochs * len(data.train_dl))\n learner.fit(num_epochs, target_metric='f1')\n idx, res = get_mean_max_metric(learner.history, \"f1\", True)\n best_reports.append(learner.history[idx])",
"_____no_output_____"
],
[
"import numpy as np",
"_____no_output_____"
]
],
[
[
"#### f1",
"_____no_output_____"
],
[
"Mean and std",
"_____no_output_____"
]
],
[
[
"np.mean([get_mean_max_metric([r]) for r in best_reports]), np.round(np.std([get_mean_max_metric([r]) for r in best_reports]), 3)",
"_____no_output_____"
]
],
[
[
"Best",
"_____no_output_____"
]
],
[
[
"get_mean_max_metric(best_reports)",
"_____no_output_____"
]
],
[
[
"#### precision",
"_____no_output_____"
],
[
"Mean and std",
"_____no_output_____"
]
],
[
[
"np.mean([get_mean_max_metric([r], \"prec\") for r in best_reports]), np.round(np.std([get_mean_max_metric([r], \"prec\") for r in best_reports]), 3)",
"_____no_output_____"
]
],
[
[
"Best",
"_____no_output_____"
]
],
[
[
"get_mean_max_metric(best_reports, \"prec\")",
"_____no_output_____"
]
],
[
[
"#### Test set",
"_____no_output_____"
]
],
[
[
"idx = np.array([get_mean_max_metric([r]) for r in best_reports]).argmax()",
"_____no_output_____"
],
[
"learner.load_model(\"/datadrive/models/conll-2003/exp_{}_attn_cased.cpt\".format(idx))",
"_____no_output_____"
],
[
"from modules.data.bert_data import get_bert_data_loader_for_predict\ndl = get_bert_data_loader_for_predict(data_path + \"test.csv\", learner)",
"_____no_output_____"
],
[
"from modules.train.train import validate_step\nprint(validate_step(dl, learner.model, learner.data.id2label, learner.sup_labels))",
"_____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",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
]
] |
ece980881118f44979cbe79d672fae731fe0d4ed | 39,503 | ipynb | Jupyter Notebook | preprocessing.ipynb | princessivy/course | 1f567398ebce4ab49ac5cfbf318fb68ab03c6c93 | [
"MIT"
] | null | null | null | preprocessing.ipynb | princessivy/course | 1f567398ebce4ab49ac5cfbf318fb68ab03c6c93 | [
"MIT"
] | null | null | null | preprocessing.ipynb | princessivy/course | 1f567398ebce4ab49ac5cfbf318fb68ab03c6c93 | [
"MIT"
] | null | null | null | 32.647107 | 228 | 0.481482 | [
[
[
"<a href=\"https://colab.research.google.com/github/princessivy/course/blob/main/preprocessing.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>",
"_____no_output_____"
],
[
"#Installs & Imports",
"_____no_output_____"
]
],
[
[
"!pip install ndjson --quiet\n!pip install beautifulsoup4 --quiet\n!pip install html2text --quiet\n!pip install nltk --quiet\n!pip install HanTa --quiet\n!pip install langdetect --quiet",
"_____no_output_____"
],
[
"import ndjson\nimport requests\nimport pandas as pd\nfrom bs4 import BeautifulSoup\nimport gzip\nfrom pathlib import Path\n# Uncomment the follwoing line if working in Google Colab \n# from google.colab import drive\nfrom collections import Counter, OrderedDict\nimport html2text\nimport numpy as np\n\nimport re\nimport nltk\nfrom nltk.corpus import stopwords\nfrom sklearn.feature_extraction import text\nfrom HanTa import HanoverTagger as ht\nfrom langdetect import detect\nimport gc\ngc.enable()\n\n#for sentiment analysis\nfrom textblob import TextBlob\n",
"_____no_output_____"
]
],
[
[
"# Dataloader \n### Test-Dataset",
"_____no_output_____"
]
],
[
[
"# Mount Google Drive\ndrive.mount('/gdrive')\ndata_path = Path('/gdrive/MyDrive/industry_data/')\nfile_name = 'test_small.ndjson.gz'\n\nwith gzip.open(data_path/file_name, \"rt\", encoding='UTF-8') as file:\n data = ndjson.load(file)\ndf_test = pd.DataFrame(data)",
"Mounted at /gdrive\n"
],
[
" \n # check for null entries\nif df_test.isnull().any(axis=None):\n print('\\nPreview of data with null values:\\nxxxxxxxxxxxxx')\n print(df_test[df_test.isnull().any(axis=1)].head(3))\n #missingno.matrix(df_test)\n #plt.show()\nelse:\n print('No null entries found')",
"_____no_output_____"
],
[
"# check for null entries\nif df_test.isnull().any(axis=None):\n print('\\nPreview of data with null values:\\nxxxxxxxxxxxxx')\n print(df_test[df_test.isnull().any(axis=1)].head(3))\n #missingno.matrix(df_test)\n #plt.show()\nelse:\n print('No null entries found')",
"No null entries found\n"
],
[
"# generate count statistics of duplicate entries\nif len(df_test[df_test.duplicated()]) > 0:\n print('Number of duplicated entries: ', len(df_test[df_test.duplicated()]))\n print(df_test[df_test.duplicated(keep=False)].sort_values(by=list(df_test.columns)).head())\nelse:\n print('No duplicated entries found')",
"No duplicated entries found\n"
]
],
[
[
"### Train-Dataset",
"_____no_output_____"
]
],
[
[
"drive.mount('/gdrive')\ndata_path = Path('/gdrive/MyDrive/industry_data/')\nfile_name = 'train_small.ndjson.gz'\nwith gzip.open(data_path/file_name, \"rt\", encoding='UTF-8') as file:\n data = []\n data = [ndjson.loads(line) for line in file]",
"_____no_output_____"
],
[
"# Nested List rausholen, Flat-List erzeugen, um Daten in DataFrame zu bekommen\nflat_list = [item for sublist in data for item in sublist]\ndf_train = pd.DataFrame(flat_list)",
"_____no_output_____"
],
[
"# check for null entries\nif df_train.isnull().any(axis=None):\n print('\\nPreview of data with null values:\\nxxxxxxxxxxxxx')\n print(df_train[df_train.isnull().any(axis=1)].head(3))\n #missingno.matrix(df_train)\n #plt.show()\nelse:\n print('No null entries found')",
"No null entries found\n"
],
[
"# generate count statistics of duplicate entries\nif len(df_train[df_train.duplicated()]) > 0:\n print('Number of duplicated entries: ', len(df_train[df_train.duplicated()]))\n print(df_train[df_train.duplicated(keep=False)].sort_values(by=list(df_train.columns)).head())\nelse:\n print(\"No duplicated entries found\")",
"_____no_output_____"
]
],
[
[
"# \"Datasaver\" & \"data-reloader\"\n### To ndjson and ndjson.gz\n\nIn order to save preprocessed data. If it is not saved row by row the run time crashes.",
"_____no_output_____"
]
],
[
[
"# save to ndjson (either regular or gzip)\n\ndef datasaver_to_zip(df, name):\n # create flat list in dict form: {'col1': 'value', 'col2': 'value', ...} from df\n flat_list_back = []\n for i in range(len(df)):\n line = df.loc[i].to_dict()\n #line['industry'] = str(line['industry']) # use if idustry number (e.g. 13) should be enclosed in '' (e.g. '13')\n flat_list_back.append([line])\n\n filename_zip = str(name) + '.ndjson.gz'\n\n with gzip.open(filename_zip, 'wt', encoding='UTF-8') as z:\n for item in flat_list_back:\n z.write('{}\\n'.format(ndjson.dumps(item)))\n\ndef datasaver_to_ndjson(df, name):\n # create flat list in dict form: {'col1': 'value', 'col2': 'value', ...} from df\n flat_list_back = []\n for i in range(len(df)):\n line = df.loc[i].to_dict()\n #line['industry'] = str(line['industry']) # use if idustry number (e.g. 13) should be enclosed in '' (e.g. '13')\n flat_list_back.append([line])\n\n filename = str(name) + '.ndjson'\n\n # https://stackoverflow.com/questions/21058935/python-json-loads-shows-valueerror-extra-data\n with open(filename, mode='w') as f:\n for item in flat_list_back:\n f.write('{}\\n'.format(ndjson.dumps(item))) ",
"_____no_output_____"
],
[
"def data_reloader_from_zip(file_name):\n with gzip.open(file_name, 'rt', encoding='UTF-8') as file:\n data = []\n data = [ndjson.loads(line.strip()) for line in file]\n\n flat_list = [item for sublist in data for item in sublist]\n df = pd.DataFrame(flat_list)\n\n return df\n\ndef data_reloader_from_ndjson(file_name):\n with open(file_name, 'rt', encoding='UTF-8') as file:\n data = []\n data = [ndjson.loads(line.strip()) for line in file]\n\n flat_list = [item for sublist in data for item in sublist]\n df = pd.DataFrame(flat_list)\n\n return df",
"_____no_output_____"
],
[
"# save file to drive \n# make sure to have folder connected (use url for access and create link for your own drive)\n# Acess: https://drive.google.com/drive/folders/1qR-9z3uFmp5Nvsb_1QrR9lU8yNE8hi6l?usp=sharing\ndrive.mount('/gdrive')\n\n!cp test_html_to_text.ndjson.gz \"/gdrive/MyDrive/industry_data_processed/\" # exchange file name",
"Drive already mounted at /gdrive; to attempt to forcibly remount, call drive.mount(\"/gdrive\", force_remount=True).\n"
]
],
[
[
"# HTML Feature-Checkout",
"_____no_output_____"
],
[
"## Checking out Tag-Occurence",
"_____no_output_____"
]
],
[
[
"all_tags = [] #der ersten 1000 Datensätze\n\nfor i in range(1000): #len(df_train)\n soup = BeautifulSoup(data[i][0]['html'], 'html.parser')\n #for tag in soup.findAll(True):\n #print(tag.name)\n tags = set(tag.name for tag in BeautifulSoup(data[i][0]['html'], 'html.parser').find_all())\n all_tags.extend(tags)\n\n #print(soup.get_text()[:1024])\n #print(tags)",
"_____no_output_____"
],
[
"# count all text, print sorted by most occurences\ncounted = Counter(all_tags)\nOrderedDict(counted.most_common())",
"_____no_output_____"
]
],
[
[
"## Get the whole Text between Tags",
"_____no_output_____"
]
],
[
[
"pd.options.mode.chained_assignment = None",
"_____no_output_____"
],
[
"def parse_to_text(html):\n soup = BeautifulSoup(html, features=\"html.parser\")\n\n # kill all script and style elements\n for script in soup([\"script\", \"style\"]):\n script.extract() # rip it out\n\n # get text\n text = soup.get_text()\n\n # break into lines and remove leading and trailing space on each\n lines = (line.strip() for line in text.splitlines())\n # break multi-headlines into a line each\n chunks = (phrase.strip() for line in lines for phrase in line.split(\" \"))\n # drop blank lines\n text = '\\n'.join(chunk for chunk in chunks if chunk)\n\n return text",
"_____no_output_____"
],
[
"# eliminate html elements from text, return text elements\n# 21 minutes for train dataset\n\n# assign column for new text\ndf_train = df_train.assign(html_to_text='')\n\nfor line in range(0, len(df_train)):\n content = parse_to_text(df_train.html[line])\n df_train.html_to_text[line] = content",
"_____no_output_____"
],
[
"# on test dataset\n# 7 minutes\n\ndf_test['html_to_text'] = ''\n\nfor line in range(0, len(df_test)):\n content = parse_to_text(df_test.html[line])\n df_test.html_to_text[line] = content",
"_____no_output_____"
],
[
"# duplicate to keep working with original df (if necessary)\ndf_test_html_to_text = df_test.copy()\ndf_test_html_to_text=df_test_html_to_text.drop(columns='html')",
"_____no_output_____"
],
[
"gc.collect()",
"_____no_output_____"
]
],
[
[
"### Preprocessing",
"_____no_output_____"
]
],
[
[
"nltk.download('stopwords')\nnltk.download('wordnet')",
"[nltk_data] Downloading package stopwords to /root/nltk_data...\n[nltk_data] Unzipping corpora/stopwords.zip.\n[nltk_data] Downloading package wordnet to /root/nltk_data...\n[nltk_data] Unzipping corpora/wordnet.zip.\n"
],
[
"# https://medium.com/analytics-vidhya/applying-text-classification-using-logistic-regression-a-comparison-between-bow-and-tf-idf-1f1ed1b83640\n\n# hier könnten wir sprachenabhängig arbeiten: clean_text_german(), clean_text_english() und anhand des lang-tags anwenden\n \ndef clean_text(mixed_text):\n '''Text Preprocessing '''\n \n # convert words to lower case\n content = mixed_text.lower()\n \n # ENGLISH use this for english text\n # Expand contractions (you've -> you have)\n #if True:\n # text = text.split()\n # new_text = []\n # for word in text:\n # if word in contractions:\n # new_text.append(contractions[word])\n # else:\n # new_text.append(word)\n # text = \" \".join(new_text)\n \n # Format words and remove unwanted characters\n #content = re.sub(r'https?:\\/\\/.*[\\r\\n]*', '', content, flags=re.MULTILINE) # brauchen wir nicht mehr, da schon geparst\n #content = re.sub(r'\\<a href', ' ', content)\n content = re.sub(r'&', '', content) \n content = re.sub(r'[_\"\\-;%()|+&=*%.,!?:#$@\\[\\]/]', ' ', content)\n content = re.sub(r'<br />', ' ', content)\n content = re.sub(r'\\'', ' ', content)\n \n # remove stopwords\n content = content.split()\n stops = set(stopwords.words('german'))\n content = [w for w in content if not w in stops]\n content = ' '.join(content)\n\n # tokenize each word\n content = nltk.WordPunctTokenizer().tokenize(content)\n \n # lemmatize each token in German (reduce words to stem)\n tagger = ht.HanoverTagger('morphmodel_ger.pgz')\n word_list = []\n for w in content:\n lemma = [lemma for (word,lemma,pos) in tagger.tag_sent(w.split())]\n word_list.append(' '.join(lemma))\n\n # ENGLISH use this for english text\n # lemmatize each token\n #lemm = nltk.stem.WordNetLemmatizer()\n #content = list(map(lambda word:list(map(lemm.lemmatize, word)), content))\n \n return word_list",
"_____no_output_____"
],
[
"df_test_html_to_text = data_reloader_from_zip('test_html_to_text.ndjson.gz')",
"_____no_output_____"
],
[
"df_test_html_to_text['html_cleaned'] = ''",
"_____no_output_____"
],
[
"len(df_test_html_to_text)",
"_____no_output_____"
],
[
"for line in range(4000):\n content = clean_text(df_test_html_to_text['html_to_text'][line])\n print(line) #debugging\n df_test_html_to_text.html_cleaned[line] = content",
"_____no_output_____"
],
[
"datasaver_to_zip(df_test_html_to_text, 'df_test_cleaned_text')",
"_____no_output_____"
]
],
[
[
"## Specific Tags for additional Features",
"_____no_output_____"
]
],
[
[
"def getHTML(url):\n # später anpassen, wenn wir live-url abfragen! evtl. Fallunterscheidung?!\n ''' r = requests.get(url)\n r.text'''\n return BeautifulSoup(url, 'html.parser')\n\n\n\n## Img-Description from IMG-Tag\ndef getImgDescriptionHTMLtag(url):\n soup = getHTML(url)\n\n results = soup.find_all('img', alt = True)\n img_description = []\n for x in range(0,len(results)):\n first_result = results[x]\n img_description.append(first_result['alt'])\n \n return list(filter(None, img_description))\n\n\n## Title\ndef getTitleHTMLtag(url):\n soup = getHTML(url)\n\n if (soup.title is not None):\n return str(soup.title.string)\n else:\n return \"\"\n\n\n## h1\ndef getH1HTMLtag(url):\n soup = getHTML(url)\n\n heading = soup.findAll('h1')\n n = len(heading)\n\n liste = []\n for x in range(n):\n liste.append(str.strip(heading[x].text))\n\n return list(filter(None, liste))\n\n\n## h2\ndef getH2HTMLtag(url):\n soup = getHTML(url)\n\n heading = soup.findAll('h2')\n n = len(heading)\n\n liste = []\n for x in range(n):\n liste.append(str.strip(heading[x].text))\n\n return list(filter(None, liste))\n\n\n## h3\ndef getH3HTMLtag(url):\n soup = getHTML(url)\n\n heading = soup.findAll('h3')\n n = len(heading)\n\n liste = []\n for x in range(n):\n liste.append(str.strip(heading[x].text))\n\n return list(filter(None, liste))\n\n\n## strong - fragwürdig\ndef getStrongHTMLtag(url):\n soup = getHTML(url)\n\n heading = soup.findAll('strong')\n n = len(heading)\n\n liste = []\n for x in range(n):\n liste.append(str.strip(heading[x].text))\n\n return list(filter(None, liste))\n\n\n## bold\ndef getBoldHTMLtag(url):\n soup = getHTML(url)\n\n heading = soup.findAll('bold')\n n = len(heading)\n\n liste = []\n for x in range(n):\n liste.append(str.strip(heading[x].text))\n\n return list(filter(None, liste))\n \n\n## language code\ndef getLangHTMLtag(url):\n \n try:\n soup = getHTML(url)\n body_text = soup.body.get_text()\n return detect(body_text)\n \n except:\n return str(\"NaN\")\n \n \n## figcaption\ndef getFigCaptionHTMLtag(url):\n soup = getHTML(url)\n\n heading = soup.findAll('figcaption')\n n = len(heading)\n\n liste = []\n for x in range(n):\n liste.append(str.strip(heading[x].text))\n\n return list(filter(None, liste))",
"_____no_output_____"
],
[
"df_test = df_test.assign(img_alt='', title='', h1='', h2='', h3='', strong='', bold='', lang_code='', figcaption='')",
"_____no_output_____"
],
[
"# Befüllen der Extra-Features\n\ndef retrieve_features(df):\n for i in range (4, 13):\n for j in range(0, len(df)):\n if i == 4:\n df.iloc[:, i][j] = getImgDescriptionHTMLtag(df.html[j])\n elif i == 5:\n df.iloc[:, i][j] = getTitleHTMLtag(df.html[j])\n elif i == 6:\n df.iloc[:, i][j] = getH1HTMLtag(df.html[j])\n elif i == 7:\n df.iloc[:, i][j] = getH2HTMLtag(df.html[j])\n elif i == 8:\n df.iloc[:, i][j] = getH3HTMLtag(df.html[j])\n elif i == 9:\n df.iloc[:, i][j] = getStrongHTMLtag(df.html[j])\n elif i == 10:\n df.iloc[:, i][j] = getBoldHTMLtag(df.html[j])\n elif i == 11:\n df.iloc[:, i][j] = getLangHTMLtag(df.html[j])\n elif i == 12:\n df.iloc[:, i][j] = getFigCaptionHTMLtag(df.html[j])",
"_____no_output_____"
],
[
"# aus List-Elementen in DataFrame einfache Strings machen, um besser cleanen zu können\ndef convert_features_toString(df):\n # img\n for x in range(len(df)):\n df.img_alt[x] = ' '.join(df.img_alt[x])\n\n # h1\n for x in range(len(df)):\n df.h1[x] = ' '.join(df.h1[x])\n\n # h2\n for x in range(len(df)):\n df.h2[x] = ' '.join(df.h2[x])\n\n # h3\n for x in range(len(df)):\n df.h3[x] = ' '.join(df.h3[x])\n\n # strong\n for x in range(len(df)):\n df.strong[x] = ' '.join(df.strong[x])\n\n # bold\n for x in range(len(df)):\n df.bold[x] = ' '.join(df.bold[x])\n\n # figcaption\n for x in range(len(df)):\n df.figcaption[x] = ' '.join(df.figcaption[x])",
"_____no_output_____"
],
[
"# alle extra-features durchgehen um zu gucken, welche wir noch durch clean_text laufen lassen müssen\ncolumns = df_train_reloaded.columns.tolist()\ncolumns = columns[4:13]",
"_____no_output_____"
],
[
"# lassen lang-code weg\ncolumns = ['img_alt','title','h1','h2','h3','strong','bold','figcaption']",
"_____no_output_____"
],
[
"# alle extra-features durch clean_text schicken, ohne lang-feature\ndef clean_dataframe(df):\n columns = ['img_alt','title','h1','h2','h3','strong','bold','figcaption']\n for x in columns:\n print(x)\n for y in range(len(df)):\n df[x][y] = clean_text(df[x][y])",
"_____no_output_____"
],
[
"# perform preprocessing\ndf_test = df_test.assign(img_alt='', title='', h1='', h2='', h3='', strong='', bold='', lang_code='', figcaption='')\nretrieve_features(df_test)\nconvert_features_toString(df_test)\nclean_dataframe(df_test)\ndf_test = df_test.drop(columns=['html'], axis=1)\ndatasaver_to_ndjson(df=df_test, name='df_test_preprocessed')\n",
"/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/2078399981.py:7: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.iloc[:, i][j] = getImgDescriptionHTMLtag(df.html[j])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/2078399981.py:9: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.iloc[:, i][j] = getTitleHTMLtag(df.html[j])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/2078399981.py:11: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.iloc[:, i][j] = getH1HTMLtag(df.html[j])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/2078399981.py:13: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.iloc[:, i][j] = getH2HTMLtag(df.html[j])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/2078399981.py:15: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.iloc[:, i][j] = getH3HTMLtag(df.html[j])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/2078399981.py:17: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.iloc[:, i][j] = getStrongHTMLtag(df.html[j])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/2078399981.py:19: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.iloc[:, i][j] = getBoldHTMLtag(df.html[j])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/2078399981.py:21: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.iloc[:, i][j] = getLangHTMLtag(df.html[j])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/2078399981.py:23: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.iloc[:, i][j] = getFigCaptionHTMLtag(df.html[j])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/41399377.py:5: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.img_alt[x] = ' '.join(df.img_alt[x])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/41399377.py:25: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.bold[x] = ' '.join(df.bold[x])\n/var/folders/0w/wzymnpfd4rjdkg4k8khhk6dc0000gn/T/ipykernel_44039/41399377.py:29: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n df.figcaption[x] = ' '.join(df.figcaption[x])\n"
]
],
[
[
"# Datei(en) exportieren",
"_____no_output_____"
]
],
[
[
"df_train_work.to_json('train_preprocessed.json')",
"_____no_output_____"
]
],
[
[
"#Sentiment-Analysis",
"_____no_output_____"
]
],
[
[
"df_train['sentiment_analysis'] =''",
"_____no_output_____"
],
[
"# spalte aus welcher sentiment-analysis gemacht wird, in string casten\ndf_train['pure_text'] = df_train['pure_text'].astype(str)",
"_____no_output_____"
],
[
"for x in range(0, len(df_train)):\n df_train.sentiment_analysis[x] = round(TextBlob(df_train['pure_text'][x]).sentiment.polarity,2)",
"_____no_output_____"
],
[
"# Überprüfung des means\ndf_train.groupby('industry_label')['sentiment_analysis'].mean()",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"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",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
]
] |
ece98d1248928ce7f953664722b7deb2bb678314 | 17,896 | ipynb | Jupyter Notebook | wrappers/Sklearn-wrapper-plus-scalers.ipynb | gverbock/feature-engine-examples | c5f6bcbe3844f51481bd102a6c21e5891468dead | [
"BSD-3-Clause"
] | null | null | null | wrappers/Sklearn-wrapper-plus-scalers.ipynb | gverbock/feature-engine-examples | c5f6bcbe3844f51481bd102a6c21e5891468dead | [
"BSD-3-Clause"
] | 4 | 2021-09-13T07:22:51.000Z | 2021-12-28T12:18:05.000Z | examples/wrappers/Sklearn-wrapper-plus-scalers.ipynb | TremaMiguel/feature_engine | 117ea3061ec9cf65f9d012aff4875d2b88e8cf71 | [
"BSD-3-Clause"
] | 5 | 2021-09-10T15:34:08.000Z | 2022-03-06T07:28:07.000Z | 30.749141 | 102 | 0.413835 | [
[
[
"import pandas as pd\nimport numpy as np\n\nimport matplotlib.pyplot as plt\n\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import StandardScaler\n\nfrom feature_engine.wrappers import SklearnTransformerWrapper",
"_____no_output_____"
],
[
"data = pd.read_csv('houseprice.csv')\ndata.head()",
"_____no_output_____"
],
[
"# let's separate into training and testing set\n\nX_train, X_test, y_train, y_test = train_test_split(\n data.drop(['Id', 'SalePrice'], axis=1), data['SalePrice'], test_size=0.3, random_state=0)\n\nX_train.shape, X_test.shape",
"_____no_output_____"
]
],
[
[
"## Scaling",
"_____no_output_____"
]
],
[
[
"cols = [var for var in X_train.columns if X_train[var].dtypes !='O']\n\ncols",
"_____no_output_____"
],
[
"# let's apply the standard scaler on the above variables\n\nscaler = SklearnTransformerWrapper(transformer = StandardScaler(),\n variables = cols)\n\nscaler.fit(X_train.fillna(0))",
"_____no_output_____"
],
[
"X_train = scaler.transform(X_train.fillna(0))\nX_test = scaler.transform(X_test.fillna(0))",
"_____no_output_____"
],
[
"# mean values, learnt by the StandardScaler\nscaler.transformer_.mean_",
"_____no_output_____"
],
[
"# std values, learnt by the StandardScaler\nscaler.transformer_.scale_",
"_____no_output_____"
],
[
"# the mean of the scaled variables is 0\nX_train[cols].mean()",
"_____no_output_____"
],
[
"# the std of the scaled variables is ~1\n\nX_train[cols].std()",
"_____no_output_____"
]
]
] | [
"code",
"markdown",
"code"
] | [
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ece9aba7673ea5c50c7c5fa6e82388d857daeb10 | 21,492 | ipynb | Jupyter Notebook | testing/sahel_cropmask/5_Accuracy_assessment.ipynb | digitalearthafrica/crop-mask | 18ae773c4d5eb71c0add765260a1032c46c68a0e | [
"Apache-2.0"
] | 11 | 2020-12-15T04:09:41.000Z | 2022-01-19T11:07:21.000Z | testing/sahel_cropmask/5_Accuracy_assessment.ipynb | digitalearthafrica/crop-mask | 18ae773c4d5eb71c0add765260a1032c46c68a0e | [
"Apache-2.0"
] | 15 | 2021-03-15T02:17:32.000Z | 2022-02-24T02:50:01.000Z | testing/sahel_cropmask/5_Accuracy_assessment.ipynb | digitalearthafrica/crop-mask | 18ae773c4d5eb71c0add765260a1032c46c68a0e | [
"Apache-2.0"
] | 4 | 2020-12-16T04:48:36.000Z | 2021-03-30T16:51:37.000Z | 29.400821 | 378 | 0.468407 | [
[
[
"# Accuracy assessment of the Sahel Africa Cropland Mask\n\n",
"_____no_output_____"
],
[
"## Description\n\nNow that we have run classifications for the Sahel Africa AEZ, its time to conduct an accuracy assessment. The data used for assessing the accuracy was collected previously and set aside. Its stored in the data/ folder: `data/Validation_samples.shp` \n\nThis notebook will output a `confusion error matrix` containing Overall, Producer's, and User's accuracy, along with the F1 score for each class.",
"_____no_output_____"
],
[
"***\n## Getting started\n\nTo run this analysis, run all the cells in the notebook, starting with the \"Load packages\" cell. ",
"_____no_output_____"
],
[
"### Load Packages",
"_____no_output_____"
]
],
[
[
"import os\nimport sys\nimport glob\nimport rasterio\nimport pandas as pd\nimport numpy as np\nimport seaborn as sn\nimport matplotlib.pyplot as plt\nimport geopandas as gpd\nfrom sklearn.metrics import f1_score\nfrom odc.io.cgroups import get_cpu_quota\n\nfrom deafrica_tools.spatial import zonal_stats_parallel",
"_____no_output_____"
]
],
[
[
"## Analysis Parameters\n\n* `pred_tif` : a binary classification of crop/no-crop output by the ML script.\n* `grd_truth` : a shapefile containing crop/no-crop points to serve as the \"ground-truth\" dataset\n* `aez_region` : a shapefile used to limit the ground truth points to the region where the model has classified crop/non-crop\n",
"_____no_output_____"
]
],
[
[
"pred_tif = \"results/classifications/20211110/Sahel_gm_mads_two_seasons_20211110_mosaic_clipped.tif\"\n# pred_tif = 'results/classifications/gfsad_sahel_masked_clipped.tif'\ngrd_truth = 'data/validation_samples.shp'",
"_____no_output_____"
]
],
[
[
"### Load the datasets\n\n`Ground truth points`",
"_____no_output_____"
]
],
[
[
"#ground truth shapefile\nground_truth = gpd.read_file(grd_truth).to_crs('EPSG:6933')",
"_____no_output_____"
],
[
"# rename the class column to 'actual'\nground_truth = ground_truth.rename(columns={'Class':'Actual'})\nground_truth.head()",
"_____no_output_____"
]
],
[
[
"Reclassify 'Actual' column to match the raster values",
"_____no_output_____"
]
],
[
[
"ground_truth['Actual'] = np.where(ground_truth['Actual']=='non-crop', 0, ground_truth['Actual'])\nground_truth['Actual'] = np.where(ground_truth['Actual']=='crop', 1, ground_truth['Actual'])",
"_____no_output_____"
]
],
[
[
"### This cell if point sampling",
"_____no_output_____"
]
],
[
[
"# #Point sampling of raster for validation purpose\n# prediction = rasterio.open(pred_tif)\n# coords = [(x,y) for x, y in zip(ground_truth.geometry.x, ground_truth.geometry.y)]\n# # Sample the raster at every point location and store values in DataFrame\n# ground_truth['Prediction'] = [int(x[0]) for x in prediction.sample(coords)]",
"_____no_output_____"
]
],
[
[
"### The next two cells if polygon sampling\n#### Convert points into polygons\n\nWhen the validation data was collected, 40x40m polygons were evaluated as either crop/non-crop rather than points, so we want to sample the raster using the same small polygons. We'll find the majority or 'mode' statistic within the polygon and use that to compare with the validation dataset.\n",
"_____no_output_____"
]
],
[
[
"#set radius (in metres) around points\nradius = 20\n\n#create circle buffer around points, then find envelope\nground_truth['geometry'] = ground_truth['geometry'].buffer(radius).envelope\n\n#export to file for use in zonal-stats\nground_truth.to_file(grd_truth[:-4]+\"_poly.shp\")",
"_____no_output_____"
]
],
[
[
"### Calculate zonal statistics\n\nWe want to know what the majority pixel value is inside each validation polygon.",
"_____no_output_____"
]
],
[
[
"zonal_stats_parallel(shp=grd_truth[:-4]+\"_poly.shp\",\n raster=pred_tif,\n statistics=['majority'],\n out_shp=grd_truth[:-4]+\"_poly.shp\",\n ncpus=round(get_cpu_quota()),\n nodata=-999)\n\n#read in the results\nx=gpd.read_file(grd_truth[:-4]+\"_poly.shp\")\n\n#add result to original ground truth array\nground_truth['Prediction'] = x['majority'].astype(np.int16)\n\n#Remove the temporary shapefile we made\n[os.remove(i) for i in glob.glob(grd_truth[:-4]+\"_poly\"+'*')]",
"/env/lib/python3.8/site-packages/fiona/collection.py:350: FionaDeprecationWarning: Collection slicing is deprecated and will be disabled in a future version.\n return self.session.__getitem__(item)\n"
]
],
[
[
"***\n\n## Create a confusion matrix",
"_____no_output_____"
]
],
[
[
"confusion_matrix = pd.crosstab(ground_truth['Actual'],\n ground_truth['Prediction'],\n rownames=['Actual'],\n colnames=['Prediction'],\n margins=True)\n\nconfusion_matrix",
"_____no_output_____"
]
],
[
[
"### Calculate User's and Producer's Accuracy",
"_____no_output_____"
],
[
"`Producer's Accuracy`",
"_____no_output_____"
]
],
[
[
"confusion_matrix[\"Producer's\"] = [confusion_matrix.loc[0, 0] / confusion_matrix.loc[0, 'All'] * 100,\n confusion_matrix.loc[1, 1] / confusion_matrix.loc[1, 'All'] * 100,\n np.nan]",
"_____no_output_____"
]
],
[
[
"`User's Accuracy`",
"_____no_output_____"
]
],
[
[
"users_accuracy = pd.Series([confusion_matrix[0][0] / confusion_matrix[0]['All'] * 100,\n confusion_matrix[1][1] / confusion_matrix[1]['All'] * 100]\n ).rename(\"User's\")\n\nconfusion_matrix = confusion_matrix.append(users_accuracy)",
"_____no_output_____"
]
],
[
[
"`Overall Accuracy`",
"_____no_output_____"
]
],
[
[
"confusion_matrix.loc[\"User's\",\"Producer's\"] = (confusion_matrix.loc[0, 0] + \n confusion_matrix.loc[1, 1]) / confusion_matrix.loc['All', 'All'] * 100",
"_____no_output_____"
]
],
[
[
"`F1 Score`\n\nThe F1 score is the harmonic mean of the precision and recall, where an F1 score reaches its best value at 1 (perfect precision and recall), and is calculated as:\n\n$$\n\\begin{aligned}\n\\text{Fscore} = 2 \\times \\frac{\\text{UA} \\times \\text{PA}}{\\text{UA} + \\text{PA}}.\n\\end{aligned}\n$$\n\nWhere UA = Users Accuracy, and PA = Producer's Accuracy",
"_____no_output_____"
]
],
[
[
"fscore = pd.Series([(2*(confusion_matrix.loc[\"User's\", 0]*confusion_matrix.loc[0, \"Producer's\"]) / (confusion_matrix.loc[\"User's\", 0]+confusion_matrix.loc[0, \"Producer's\"])) / 100,\n f1_score(ground_truth['Actual'].astype(np.int8), ground_truth['Prediction'].astype(np.int8), average='binary')]\n ).rename(\"F-score\")\n\nconfusion_matrix = confusion_matrix.append(fscore)",
"_____no_output_____"
]
],
[
[
"### Tidy Confusion Matrix\n\n* Limit decimal places,\n* Add readable class names\n* Remove non-sensical values ",
"_____no_output_____"
]
],
[
[
"# round numbers\nconfusion_matrix = confusion_matrix.round(decimals=2)",
"_____no_output_____"
],
[
"# rename booleans to class names\nconfusion_matrix = confusion_matrix.rename(columns={0:'Non-crop', 1:'Crop', 'All':'Total'},\n index={0:'Non-crop', 1:'Crop', 'All':'Total'})",
"_____no_output_____"
],
[
"#remove the nonsensical values in the table\nconfusion_matrix.loc[\"User's\", 'Total'] = '--'\nconfusion_matrix.loc['Total', \"Producer's\"] = '--'\nconfusion_matrix.loc[\"F-score\", 'Total'] = '--'\nconfusion_matrix.loc[\"F-score\", \"Producer's\"] = '--'",
"_____no_output_____"
],
[
"confusion_matrix",
"_____no_output_____"
]
],
[
[
"### Export csv",
"_____no_output_____"
]
],
[
[
"# confusion_matrix.to_csv('results/Sahel_confusion_matrix.csv')",
"_____no_output_____"
]
],
[
[
"## Next steps\n\nThis is the last notebook in the `Southern Africa Cropland Mask` workflow! To revist any of the other notebooks, use the links below.\n\n1. [Extract_training_data](1_Extract_training_data.ipynb) \n2. [Inspect_training_data](2_Inspect_training_data.ipynb)\n3. [Train_fit_evaluate_classifier](3_Train_fit_evaluate_classifier.ipynb)\n4. [Predict](4_Predict.ipynb)\n5. [Object-based_filtering](5_Object-based_filtering.ipynb)\n6. **Accuracy_assessment (this notebook)**",
"_____no_output_____"
],
[
"***\n\n## Additional information\n\n**License:** The code in this notebook is licensed under the [Apache License, Version 2.0](https://www.apache.org/licenses/LICENSE-2.0). \nDigital Earth Africa data is licensed under the [Creative Commons by Attribution 4.0](https://creativecommons.org/licenses/by/4.0/) license.\n\n**Contact:** If you need assistance, please post a question on the [Open Data Cube Slack channel](http://slack.opendatacube.org/) or on the [GIS Stack Exchange](https://gis.stackexchange.com/questions/ask?tags=open-data-cube) using the `open-data-cube` tag (you can view previously asked questions [here](https://gis.stackexchange.com/questions/tagged/open-data-cube)).\nIf you would like to report an issue with this notebook, you can file one on [Github](https://github.com/digitalearthafrica/deafrica-sandbox-notebooks).\n\n**Last modified:** Dec 2020\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"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
]
] |
ece9be8f645f715989fc6f3f9bd5f5351e4e2a13 | 75,535 | ipynb | Jupyter Notebook | ex6/Exercise6.ipynb | doyeonkp/BigData_2017 | 51e71afb364d70e30e52b546331e0a44f1265230 | [
"MIT"
] | null | null | null | ex6/Exercise6.ipynb | doyeonkp/BigData_2017 | 51e71afb364d70e30e52b546331e0a44f1265230 | [
"MIT"
] | null | null | null | ex6/Exercise6.ipynb | doyeonkp/BigData_2017 | 51e71afb364d70e30e52b546331e0a44f1265230 | [
"MIT"
] | null | null | null | 114.273828 | 15,590 | 0.856662 | [
[
[
"import pandas as p\ndata = p.read_csv('train.csv')\ndata.head()",
"_____no_output_____"
],
[
"X = data.drop('date',axis=1)\nX = X.drop('Occupancy', axis=1)\nY = data['Occupancy']",
"_____no_output_____"
],
[
"maxdepth = [2, 5, 10, 15, 20]\nk = [1, 2, 3, 4, 5, 10,15]\nc = [0.001, 0.01, 0.1, 0.5, 1]",
"_____no_output_____"
],
[
"from sklearn import tree\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.model_selection import cross_val_score\naccuracy = []\nfor i in maxdepth:\n clf = tree.DecisionTreeClassifier(max_depth=i)\n scores = cross_val_score(clf, X, Y, cv=5)\n accuracy.append(scores.mean())\n",
"_____no_output_____"
],
[
"accuracy",
"_____no_output_____"
],
[
"import pandas as p\ndata = p.read_csv('test.csv')\ndata.head()\n\nX_test = data.drop('date',axis=1)\nX_test = X_test.drop('Occupancy', axis=1)\nY_test = data['Occupancy']",
"_____no_output_____"
],
[
"%matplotlib inline\nimport matplotlib\nimport matplotlib.pyplot as plt \nplt.plot(maxdepth,accuracy,'ro-')",
"_____no_output_____"
],
[
"from sklearn import tree\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.model_selection import cross_val_score\naccuracy = []\nfor i in k:\n clf = KNeighborsClassifier(n_neighbors=i)\n scores = cross_val_score(clf, X, Y, cv=5)\n accuracy.append(scores.mean())",
"_____no_output_____"
],
[
"accuracy",
"_____no_output_____"
],
[
"%matplotlib inline\nimport matplotlib\nimport matplotlib.pyplot as plt \nplt.plot(k,accuracy,'ro-')",
"_____no_output_____"
],
[
"from sklearn import tree\nfrom sklearn.metrics import accuracy_score\nfrom sklearn.model_selection import cross_val_score\nfrom sklearn.linear_model import LogisticRegression\naccuracy = []\nfor i in c:\n clf = LogisticRegression(C=i)\n scores = cross_val_score(clf, X, Y, cv=5)\n accuracy.append(scores.mean())\n ",
"_____no_output_____"
],
[
"accuracy",
"_____no_output_____"
],
[
"%matplotlib inline\nimport matplotlib\nimport matplotlib.pyplot as plt \nplt.plot(c,accuracy,'ro-')",
"_____no_output_____"
],
[
"clf = tree.DecisionTreeClassifier(max_depth=5.0)\nclf = clf.fit(X, Y)\nY_pred = clf.predict(X_test)\naccuracy_test_Decision = accuracy_score(Y_test,Y_pred)\n\naccuracy_test_Decision",
"_____no_output_____"
],
[
"clf = KNeighborsClassifier(n_neighbors=3)\nclf = clf.fit(X, Y)\nY_pred = clf.predict(X_test)\naccuracy_test_Knearest = accuracy_score(Y_test,Y_pred)\n\naccuracy_test_Knearest",
"_____no_output_____"
],
[
"clf = LogisticRegression(C=1.0)\nclf = clf.fit(X, Y)\nY_pred = clf.predict(X_test)\naccuracy_test_logistic = accuracy_score(Y_test,Y_pred)\n\naccuracy_test_logistic",
"_____no_output_____"
],
[
"accuracy_test_Decision=[]\naccuracy_score_list=[]\nfor i in maxdepth:\n clf = tree.DecisionTreeClassifier(max_depth=i)\n clf = clf.fit(X, Y)\n Y_pred_train = clf.predict(X)\n Y_pred = clf.predict(X_test)\n accuracy_score_list.append(accuracy_score(Y,Y_pred_train))\n accuracy_test_Decision.append(accuracy_score(Y_test,Y_pred))",
"_____no_output_____"
],
[
"import matplotlib.pyplot as plt \nplt.plot(maxdepth,accuracy_score_list,'ro-',maxdepth,accuracy_test_Decision,'bv--')",
"_____no_output_____"
],
[
"accuracy_test_Knearest=[]\naccuracy_score_list=[]\nfor i in maxdepth:\n clf = KNeighborsClassifier(n_neighbors=i)\n clf = clf.fit(X, Y)\n Y_pred_train = clf.predict(X)\n Y_pred = clf.predict(X_test)\n accuracy_score_list.append(accuracy_score(Y,Y_pred_train))\n accuracy_test_Knearest.append(accuracy_score(Y_test,Y_pred))",
"_____no_output_____"
],
[
"from sklearn import linear_model\nfrom sklearn.svm import SVC\n\nDesicion_acc_list = []\nKNeighbors_acc_list=[]\nlogistic_acc_list = []\n\nclf = tree.DecisionTreeClassifier(max_depth=5.0)\nclf = clf.fit(X, Y)\nY_pred = clf.predict(X_test)\naccuracy_test_Decision = accuracy_score(Y_test,Y_pred)\n\nclf = KNeighborsClassifier(n_neighbors=3)\nclf = clf.fit(X, Y)\nY_pred = clf.predict(X_test)\naccuracy_test_Knearest = accuracy_score(Y_test,Y_pred)\n\n \nclf = LogisticRegression(C=1.0)\nclf = clf.fit(X, Y)\nY_pred = clf.predict(X_test)\naccuracy_test_logistic = accuracy_score(Y_test,Y_pred)\n\nmethods = ['Dtree','Kneighbor','logistic']\nacc = [accuracy_test_Decision,accuracy_test_Knearest,accuracy_test_logistic]\nplt.bar([1, 2, 3], acc)\nplt.xticks([1,2,3], methods)\n\n# ystick = [0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.85,0.97,0.98,0.9]\n\nprint accuracy_test_Decision\n\nprint accuracy_test_Knearest\n\nprint accuracy_test_logistic\n\n\n",
"0.984753607405\n0.988429077049\n0.987612306017\n"
],
[
"#######################################\n# Show differency to re-scale the y-axis by yscale('log')\n#######################################\nmethods = ['Dtree','Kneighbor','logistic']\nacc = [accuracy_test_Decision,accuracy_test_Knearest,accuracy_test_logistic]\nplt.bar([1, 2, 3], acc)\nplt.xticks([1,2,3], methods)\nplt.yscale(\"log\")",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ece9c0fa4a9d92cf49cc96a40eeccf114caca44c | 24,547 | ipynb | Jupyter Notebook | site/en/r1/tutorials/images/hub_with_keras.ipynb | BlazerYoo/docs | 37094bf40829f515e1acf683fdc452cdb02738e9 | [
"Apache-2.0"
] | 5,672 | 2018-08-27T18:49:33.000Z | 2022-03-31T07:52:12.000Z | site/en/r1/tutorials/images/hub_with_keras.ipynb | agentdavidjoseph/docs | 9fbb00bd50f962d5edfba09f426b761ae9283aec | [
"Apache-2.0"
] | 1,635 | 2018-08-28T15:27:17.000Z | 2022-03-23T23:15:14.000Z | site/en/r1/tutorials/images/hub_with_keras.ipynb | agentdavidjoseph/docs | 9fbb00bd50f962d5edfba09f426b761ae9283aec | [
"Apache-2.0"
] | 6,035 | 2018-08-27T19:13:09.000Z | 2022-03-31T08:55:13.000Z | 26.710555 | 257 | 0.498595 | [
[
[
"##### Copyright 2018 The TensorFlow Authors.",
"_____no_output_____"
]
],
[
[
"#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.",
"_____no_output_____"
]
],
[
[
"# Hub with Keras\n\n<table class=\"tfo-notebook-buttons\" align=\"left\">\n <td>\n <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/docs/blob/master/site/en/r1/tutorials/images/hub_with_keras.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://github.com/tensorflow/docs/blob/master/site/en/r1/tutorials/images/hub_with_keras.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n </td>\n <td>\n <a href=\"https://tfhub.dev/s?module-type=image-classification\"><img src=\"https://www.tensorflow.org/images/hub_logo_32px.png\" />See TF Hub model</a>\n </td>\n</table>",
"_____no_output_____"
],
[
"> Note: This is an archived TF1 notebook. These are configured\nto run in TF2's \n[compatbility mode](https://www.tensorflow.org/guide/migrate)\nbut will run in TF1 as well. To use TF1 in Colab, use the\n[%tensorflow_version 1.x](https://colab.research.google.com/notebooks/tensorflow_version.ipynb)\nmagic.",
"_____no_output_____"
],
[
"[TensorFlow Hub](http://tensorflow.org/hub) is a way to share pretrained model components. See the [TensorFlow Module Hub](https://tfhub.dev/) for a searchable listing of pre-trained models.\n\nThis tutorial demonstrates:\n\n1. How to use TensorFlow Hub with `tf.keras`.\n1. How to do image classification using TensorFlow Hub.\n1. How to do simple transfer learning.",
"_____no_output_____"
],
[
"## Setup",
"_____no_output_____"
],
[
"### Imports",
"_____no_output_____"
]
],
[
[
"!pip install -U tensorflow_hub",
"_____no_output_____"
],
[
"import matplotlib.pylab as plt\n\nimport tensorflow.compat.v1 as tf\n",
"_____no_output_____"
],
[
"import os\nimport tensorflow_hub as hub\nfrom tensorflow.keras import layers\n\n# Load compressed models from tensorflow_hub\nos.environ[\"TFHUB_MODEL_LOAD_FORMAT\"] = \"COMPRESSED\"",
"_____no_output_____"
]
],
[
[
"## An ImageNet classifier",
"_____no_output_____"
],
[
"### Download the classifier\n\nUse `hub.module` to load a mobilenet, and `tf.keras.layers.Lambda` to wrap it up as a keras layer.\n\nThe URL of any [TF2-compatible image classification module](https://tfhub.dev/s?module-type=image-classification&q=tf2) from tfhub.dev will work here.",
"_____no_output_____"
]
],
[
[
"classifier_url =\"https://tfhub.dev/google/tf2-preview/mobilenet_v2/classification/2\" #@param {type:\"string\"}",
"_____no_output_____"
],
[
"IMAGE_SHAPE = (224, 224)\n\nclassifier = tf.keras.Sequential([\n hub.KerasLayer(classifier_url, input_shape=IMAGE_SHAPE+(3,))\n])",
"_____no_output_____"
]
],
[
[
"### Run it on a single image",
"_____no_output_____"
],
[
"Download a single image to try the model on.",
"_____no_output_____"
]
],
[
[
"import numpy as np\nimport PIL.Image as Image\n\ngrace_hopper = tf.keras.utils.get_file('image.jpg','https://storage.googleapis.com/download.tensorflow.org/example_images/grace_hopper.jpg')\ngrace_hopper = Image.open(grace_hopper).resize(IMAGE_SHAPE)\ngrace_hopper",
"_____no_output_____"
],
[
"grace_hopper = np.array(grace_hopper)/255.0\ngrace_hopper.shape",
"_____no_output_____"
]
],
[
[
"Add a batch dimension, and pass the image to the model.",
"_____no_output_____"
]
],
[
[
"result = classifier.predict(grace_hopper[np.newaxis, ...])\nresult.shape",
"_____no_output_____"
]
],
[
[
"The result is a 1001 element vector of logits, rating the probability of each class for the image.\n\nSo the top class ID can be found with argmax:",
"_____no_output_____"
]
],
[
[
"predicted_class = np.argmax(result[0], axis=-1)\npredicted_class",
"_____no_output_____"
]
],
[
[
"### Decode the predictions\n\nWe have the predicted class ID,\nFetch the `ImageNet` labels, and decode the predictions",
"_____no_output_____"
]
],
[
[
"labels_path = tf.keras.utils.get_file('ImageNetLabels.txt','https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt')\nimagenet_labels = np.array(open(labels_path).read().splitlines())",
"_____no_output_____"
],
[
"plt.imshow(grace_hopper)\nplt.axis('off')\npredicted_class_name = imagenet_labels[predicted_class]\n_ = plt.title(\"Prediction: \" + predicted_class_name.title())",
"_____no_output_____"
]
],
[
[
"## Simple transfer learning",
"_____no_output_____"
],
[
"Using TF Hub it is simple to retrain the top layer of the model to recognize the classes in our dataset.",
"_____no_output_____"
],
[
"### Dataset\n\n For this example you will use the TensorFlow flowers dataset:",
"_____no_output_____"
]
],
[
[
"data_root = tf.keras.utils.get_file(\n 'flower_photos','https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',\n untar=True)",
"_____no_output_____"
]
],
[
[
"The simplest way to load this data into our model is using `tf.keras.preprocessing.image.ImageDataGenerator`,\n\nAll of TensorFlow Hub's image modules expect float inputs in the `[0, 1]` range. Use the `ImageDataGenerator`'s `rescale` parameter to achieve this.\n\nThe image size will be handled later.",
"_____no_output_____"
]
],
[
[
"image_generator = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1/255)\nimage_data = image_generator.flow_from_directory(str(data_root), target_size=IMAGE_SHAPE)",
"_____no_output_____"
]
],
[
[
"The resulting object is an iterator that returns `image_batch, label_batch` pairs.",
"_____no_output_____"
]
],
[
[
"for image_batch, label_batch in image_data:\n print(\"Image batch shape: \", image_batch.shape)\n print(\"Label batch shape: \", label_batch.shape)\n break",
"_____no_output_____"
]
],
[
[
"### Run the classifier on a batch of images",
"_____no_output_____"
],
[
"Now run the classifier on the image batch.",
"_____no_output_____"
]
],
[
[
"result_batch = classifier.predict(image_batch)\nresult_batch.shape",
"_____no_output_____"
],
[
"predicted_class_names = imagenet_labels[np.argmax(result_batch, axis=-1)]\npredicted_class_names",
"_____no_output_____"
]
],
[
[
"Now check how these predictions line up with the images:",
"_____no_output_____"
]
],
[
[
"plt.figure(figsize=(10,9))\nplt.subplots_adjust(hspace=0.5)\nfor n in range(30):\n plt.subplot(6,5,n+1)\n plt.imshow(image_batch[n])\n plt.title(predicted_class_names[n])\n plt.axis('off')\n_ = plt.suptitle(\"ImageNet predictions\")",
"_____no_output_____"
]
],
[
[
"See the `LICENSE.txt` file for image attributions.\n\nThe results are far from perfect, but reasonable considering that these are not the classes the model was trained for (except \"daisy\").",
"_____no_output_____"
],
[
"### Download the headless model\n\nTensorFlow Hub also distributes models without the top classification layer. These can be used to easily do transfer learning.\n\nThe URL of any [TF2-compatible image feature vector module](https://tfhub.dev/s?module-type=image-feature-vector&q=tf2) from tfhub.dev will work here.",
"_____no_output_____"
]
],
[
[
"feature_extractor_url = \"https://tfhub.dev/google/tf2-preview/mobilenet_v2/feature_vector/2\" #@param {type:\"string\"}",
"_____no_output_____"
]
],
[
[
"Create the module, and check the expected image size:",
"_____no_output_____"
]
],
[
[
"feature_extractor_layer = hub.KerasLayer(feature_extractor_url,\n input_shape=(224,224,3))",
"_____no_output_____"
]
],
[
[
"The feature extractor returns a 1280-element vector for each image.",
"_____no_output_____"
]
],
[
[
"feature_batch = feature_extractor_layer(image_batch)\nprint(feature_batch.shape)",
"_____no_output_____"
]
],
[
[
"Freeze the variables in the feature extractor layer, so that the training only modifies the new classifier layer.",
"_____no_output_____"
]
],
[
[
"feature_extractor_layer.trainable = False",
"_____no_output_____"
]
],
[
[
"### Attach a classification head\n\nNow wrap the hub layer in a `tf.keras.Sequential` model, and add a new classification layer.",
"_____no_output_____"
]
],
[
[
"model = tf.keras.Sequential([\n feature_extractor_layer,\n layers.Dense(image_data.num_classes, activation='softmax')\n])\n\nmodel.summary()",
"_____no_output_____"
],
[
"predictions = model(image_batch)",
"_____no_output_____"
],
[
"predictions.shape",
"_____no_output_____"
]
],
[
[
"### Train the model\n\nUse compile to configure the training process:",
"_____no_output_____"
]
],
[
[
"model.compile(\n optimizer=tf.keras.optimizers.Adam(),\n loss='categorical_crossentropy',\n metrics=['acc'])",
"_____no_output_____"
]
],
[
[
"Now use the `.fit` method to train the model.\n\nTo keep this example short train just 2 epochs. To visualize the training progress, use a custom callback to log the loss and accuracy of each batch individually, instead of the epoch average.",
"_____no_output_____"
]
],
[
[
"class CollectBatchStats(tf.keras.callbacks.Callback):\n def __init__(self):\n self.batch_losses = []\n self.batch_acc = []\n\n def on_train_batch_end(self, batch, logs=None):\n self.batch_losses.append(logs['loss'])\n self.batch_acc.append(logs['acc'])\n self.model.reset_metrics()",
"_____no_output_____"
],
[
"steps_per_epoch = np.ceil(image_data.samples/image_data.batch_size)\n\nbatch_stats_callback = CollectBatchStats()\n\nhistory = model.fit(image_data, epochs=2,\n steps_per_epoch=steps_per_epoch,\n callbacks = [batch_stats_callback])",
"_____no_output_____"
]
],
[
[
"Now after, even just a few training iterations, we can already see that the model is making progress on the task.",
"_____no_output_____"
]
],
[
[
"plt.figure()\nplt.ylabel(\"Loss\")\nplt.xlabel(\"Training Steps\")\nplt.ylim([0,2])\nplt.plot(batch_stats_callback.batch_losses)",
"_____no_output_____"
],
[
"plt.figure()\nplt.ylabel(\"Accuracy\")\nplt.xlabel(\"Training Steps\")\nplt.ylim([0,1])\nplt.plot(batch_stats_callback.batch_acc)",
"_____no_output_____"
]
],
[
[
"### Check the predictions\n\nTo redo the plot from before, first get the ordered list of class names:",
"_____no_output_____"
]
],
[
[
"class_names = sorted(image_data.class_indices.items(), key=lambda pair:pair[1])\nclass_names = np.array([key.title() for key, value in class_names])\nclass_names",
"_____no_output_____"
]
],
[
[
"Run the image batch through the model and convert the indices to class names.",
"_____no_output_____"
]
],
[
[
"predicted_batch = model.predict(image_batch)\npredicted_id = np.argmax(predicted_batch, axis=-1)\npredicted_label_batch = class_names[predicted_id]",
"_____no_output_____"
]
],
[
[
"Plot the result",
"_____no_output_____"
]
],
[
[
"label_id = np.argmax(label_batch, axis=-1)",
"_____no_output_____"
],
[
"plt.figure(figsize=(10,9))\nplt.subplots_adjust(hspace=0.5)\nfor n in range(30):\n plt.subplot(6,5,n+1)\n plt.imshow(image_batch[n])\n color = \"green\" if predicted_id[n] == label_id[n] else \"red\"\n plt.title(predicted_label_batch[n].title(), color=color)\n plt.axis('off')\n_ = plt.suptitle(\"Model predictions (green: correct, red: incorrect)\")",
"_____no_output_____"
]
],
[
[
"## Export your model\n\nNow that you've trained the model, export it as a saved model:",
"_____no_output_____"
]
],
[
[
"import time\nt = time.time()\n\nexport_path = \"/tmp/saved_models/{}\".format(int(t))\ntf.keras.experimental.export_saved_model(model, export_path)\n\nexport_path",
"_____no_output_____"
]
],
[
[
"Now confirm that we can reload it, and it still gives the same results:",
"_____no_output_____"
]
],
[
[
"reloaded = tf.keras.experimental.load_from_saved_model(export_path, custom_objects={'KerasLayer':hub.KerasLayer})",
"_____no_output_____"
],
[
"result_batch = model.predict(image_batch)\nreloaded_result_batch = reloaded.predict(image_batch)",
"_____no_output_____"
],
[
"abs(reloaded_result_batch - result_batch).max()",
"_____no_output_____"
]
],
[
[
"This saved model can be loaded for inference later, or converted to [TFLite](https://www.tensorflow.org/lite/convert/) or [TFjs](https://github.com/tensorflow/tfjs-converter).\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"
] | [
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
]
] |
ece9c21c5d681500710961bc7900894bfe61761a | 9,325 | ipynb | Jupyter Notebook | tutorials/using-dask/1.intro-to-dask.ipynb | kseager/azureml-examples | 02e575cc19a1dec55e42fbb00352dc06b54eb8e7 | [
"MIT"
] | 1 | 2021-04-28T11:26:59.000Z | 2021-04-28T11:26:59.000Z | tutorials/using-dask/1.intro-to-dask.ipynb | kseager/azureml-examples | 02e575cc19a1dec55e42fbb00352dc06b54eb8e7 | [
"MIT"
] | null | null | null | tutorials/using-dask/1.intro-to-dask.ipynb | kseager/azureml-examples | 02e575cc19a1dec55e42fbb00352dc06b54eb8e7 | [
"MIT"
] | null | null | null | 22.96798 | 377 | 0.544129 | [
[
[
"# Introduction to Dask\n\nIn this notebook, we'll learn how to use [Dask](https://dask.org) for reading and processing data from Azure.",
"_____no_output_____"
],
[
"## Install required packages",
"_____no_output_____"
]
],
[
[
"!pip install --upgrade dask distributed dask-sql bokeh adlfs fsspec fastparquet pyarrow python-snappy lz4 \"pandas>=1.2.0\"",
"_____no_output_____"
]
],
[
[
"## Get AML Workspace\n\nYou can use the AML workspace to retrieve datastores and keyvaults for accessing data credentials securely.",
"_____no_output_____"
]
],
[
[
"from azureml.core import Workspace\n\nws = Workspace.from_config()\nws",
"_____no_output_____"
]
],
[
[
"## Create a distributed client\n\nThe [client](https://distributed.dask.org/en/latest/client.html) is the primary entrypoint for parallel processing with Dask. Calling it without inputs will create a local distributed scheduler, utilizing all the CPUs and cores on your machine. This can be useful for faster processing of larger in memory dataframes, or even computations on out of memory (OOM) data. \n\nWhen your local machine isn't powerful enough, you can provision a larger VM in Azure - the M series has 100+ CPUs and TBs of RAM. If this still isn't powerful enough, you can create a distributed Dask cluster on most hardware - see [the Dask setup guide](https://docs.dask.org/en/latest/setup.html) for details.\n\nIf you still need acceleration, [RAPIDSAI](https://github.com/rapidsai) further extends the PyData APIs on GPUs.\n\n**Make sure you check out the dashboard!**",
"_____no_output_____"
]
],
[
[
"from distributed import Client\n\n# initialize local client\nc = Client()\n\n# print Python objects\nprint(c)\nprint(c.dashboard_link)\n\n# print notebook widget widget\nc",
"_____no_output_____"
]
],
[
[
"## Reading cloud data\n\nReading data from the cloud is as easy! Python implements various cloud protocols, including ``az`` for Blob and ADLSv2 and ``adl`` for ADLSv1.\n\n### Public Data\n\nPublic data can simply be read via ``https``.\n",
"_____no_output_____"
]
],
[
[
"account_name = \"azuremlexamples\"\ncontainer_name = \"datasets\"\n\nstorage_options = {\"account_name\": account_name}",
"_____no_output_____"
],
[
"data_uri = f\"https://{account_name}.blob.core.windows.net/{container_name}/iris.csv\"\ndata_uri",
"_____no_output_____"
],
[
"import pandas as pd\n\ndf = pd.read_csv(data_uri)\ndf",
"_____no_output_____"
]
],
[
[
"alternatively, we can use the ``az`` protocol and pass in ``storage_options``:",
"_____no_output_____"
]
],
[
[
"data_uri = f\"az://{container_name}/iris.csv\"\ndata_uri",
"_____no_output_____"
],
[
"import pandas as pd\n\ndf = pd.read_csv(data_uri, storage_options=storage_options)\ndf",
"_____no_output_____"
]
],
[
[
"## Private Data \n\nPassing in storage options allows for reading private data. For instance, you can easily retrieve the information from an Azure ML Datastore:\n\n```python\nfrom azureml.core import Workspace\n\nws = Workspace.from_config()\nds = ws.get_default_datastore() # ws.datastores[\"my-datastore-name\"]\n\ncontainer_name = ds.container_name\nstorage_options = {\n \"account_name\": ds.account_name,\n \"account_key\": ds.account_key,\n}\n```",
"_____no_output_____"
]
],
[
[
"from adlfs import AzureBlobFileSystem\n\nds = ws.get_default_datastore()\n\ncontainer_name = ds.container_name\nstorage_options = {\"account_name\": ds.account_name, \"account_key\": ds.account_key}\n\nfs = AzureBlobFileSystem(**storage_options)\nfs",
"_____no_output_____"
],
[
"fs.ls(f\"{container_name}\")",
"_____no_output_____"
]
],
[
[
"## Pythonic Filesystem\n\nIn the previous section, we used [ADLFS](https://github.com/dask/adlfs) to initialize a Pythonic filesystem and perform operations.\n\nThe below cell demonstrate some basic operations to raed and manipulate data in Python.",
"_____no_output_____"
]
],
[
[
"color = \"green\"\ncontainer_name = \"nyctlc\"\nstorage_options = {\"account_name\": \"azureopendatastorage\"}",
"_____no_output_____"
],
[
"fs = AzureBlobFileSystem(**storage_options)\nfs",
"_____no_output_____"
],
[
"fs.ls(f\"{container_name}\")",
"_____no_output_____"
],
[
"fs.ls(f\"{container_name}/{color}\")",
"_____no_output_____"
],
[
"fs.ls(f\"{container_name}/{color}/puYear=2016/\")",
"_____no_output_____"
],
[
"files = fs.glob(f\"{container_name}/{color}/puYear=2016/puMonth=12/*.parquet\")\nfiles = [f\"az://{file}\" for file in files]\nfiles[-5:]",
"_____no_output_____"
],
[
"import dask.dataframe as dd\n\nddf = (\n dd.read_parquet(files, storage_options=storage_options)\n .repartition(npartitions=8)\n .persist()\n)\nddf",
"_____no_output_____"
],
[
"%%time\nlen(ddf)",
"_____no_output_____"
],
[
"%%time\nlen(ddf)",
"_____no_output_____"
],
[
"ddf.info()",
"_____no_output_____"
],
[
"import matplotlib.pyplot as plt\n\nplt.style.use(\"dark_background\")\n\nddf[\"tipAmount\"].compute().hist(\n figsize=(16, 8),\n bins=256,\n range=(0.1, 20),\n)",
"_____no_output_____"
],
[
"df = ddf.compute()\ndf.info()",
"_____no_output_____"
],
[
"%%time\ndf.describe()",
"_____no_output_____"
],
[
"%%time\ngbs = round(df.memory_usage(index=True, deep=True).sum() / 1e9, 2)\nprint(f\"df is {gbs} GBs\")",
"_____no_output_____"
],
[
"%%time\ngbs = round(ddf.memory_usage(index=True, deep=True).sum().compute() / 1e9, 2)\nprint(f\"ddf is {gbs} GBs\")",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ece9cd3dadb72555ca08fc050f9335b79ff12424 | 516,388 | ipynb | Jupyter Notebook | beginner-python/002-plots.ipynb | OHBM-Seattle/brain-hacking-101 | 6dabcd1018e50dac6dcba04831d4314920b1d225 | [
"Apache-2.0"
] | 1 | 2018-08-24T02:57:05.000Z | 2018-08-24T02:57:05.000Z | beginner-python/002-plots.ipynb | sinodanish/brain-hacking-101 | 6dabcd1018e50dac6dcba04831d4314920b1d225 | [
"Apache-2.0"
] | null | null | null | beginner-python/002-plots.ipynb | sinodanish/brain-hacking-101 | 6dabcd1018e50dac6dcba04831d4314920b1d225 | [
"Apache-2.0"
] | null | null | null | 1,426.486188 | 159,988 | 0.94949 | [
[
[
"### Brain-hacking 101\n\nAuthor: [**Ariel Rokem**](http://arokem.org), [**The University of Washington eScience Institute**](http://escience.washington.edu)",
"_____no_output_____"
],
[
"### Hack 2: Look at your data\n\nA picture is worth a thousand words. Data visualization allows you to look directly at different aspects of the data that are not readily available to you by just looking at the numbers. \n\nIn this tutorial, we will look at the FIAC data using the [Matplotlib](http://matplotlib.org) software library. Matplotlib is an open-source software library that can be used to create beautiful 2-d data visualizations, such as lines, scatter-plots, and images. It can be used to produce publication-quality figures in a variety of file-formats.\n\nLet's ",
"_____no_output_____"
]
],
[
[
"import numpy as np\nimport nibabel as nib",
"_____no_output_____"
],
[
"import matplotlib as mpl\nimport matplotlib.pyplot as plt",
"_____no_output_____"
],
[
"%matplotlib inline",
"_____no_output_____"
],
[
"img = nib.load('./data/run1.nii.gz')\ndata = img.get_data()",
"_____no_output_____"
],
[
"fig, ax = plt.subplots(1)\nax.plot(data[32, 32, 15, :])",
"_____no_output_____"
]
],
[
[
"Congratulations! You first MPL plot. Let's make this a little bit larger, use a style to make it look better, and add some annotations. ",
"_____no_output_____"
]
],
[
[
"mpl.style.use('bmh')\nfig, ax = plt.subplots(1)\nax.plot(data[32, 32, 15, :])\nax.set_xlabel('Time (TR)')\nax.set_ylabel('MRI signal (a.u.)')\nax.set_title('Time-series from voxel [32, 32, 15]')\nfig.set_size_inches([12, 6])",
"_____no_output_____"
]
],
[
[
"## Impressions about the data?",
"_____no_output_____"
],
[
"If we want to compare several voxels side by side we can plot them on the same axis:",
"_____no_output_____"
]
],
[
[
"fig, ax = plt.subplots(1)\nax.plot(data[32, 32, 15, :])\nax.plot(data[32, 32, 14, :])\nax.plot(data[32, 32, 13, :])\nax.plot(data[32, 32, 12, :])\nax.set_xlabel('Time (TR)')\nax.set_ylabel('MRI signal (a.u.)')\nax.set_title('Time-series from a few voxels')\nfig.set_size_inches([12, 6])",
"_____no_output_____"
]
],
[
[
"Alternatively, we can create different subplots for each time-series",
"_____no_output_____"
]
],
[
[
"fig, ax = plt.subplots(2, 2)\n# ax is now an array!\nax[0, 0].plot(data[32, 32, 15, :])\nax[0, 1].plot(data[32, 32, 14, :])\nax[1, 0].plot(data[32, 32, 13, :])\nax[1, 1].plot(data[32, 32, 12, :])\nax[1, 0].set_xlabel('Time (TR)')\nax[1, 1].set_xlabel('Time (TR)')\nax[0, 0].set_ylabel('MRI signal (a.u.)')\nax[1, 0].set_ylabel('MRI signal (a.u.)')\n# Note that we now set the title through the fig object!\nfig.suptitle('Time-series from a few voxels')\nfig.set_size_inches([12, 6])",
"_____no_output_____"
]
],
[
[
"Another kind of plot is an image. For example, we can take a look at the mean and standard deviation of the time-series for one entire slice:",
"_____no_output_____"
]
],
[
[
"fig, ax = plt.subplots(1, 2)\n# We'll use a reasonable colormap, and no smoothing:\nax[0].matshow(np.mean(data[:, :, 15], -1), cmap=mpl.cm.hot)\nax[0].axis('off')\nax[1].matshow(np.std(data[:, :, 15], -1), cmap=mpl.cm.hot)\nax[1].axis('off')\nfig.set_size_inches([12, 6])\n# You can save the figure to file:\nfig.savefig('mean_and_std.png')",
"_____no_output_____"
]
],
[
[
"There are many other kinds of figures you could create:",
"_____no_output_____"
]
],
[
[
"fig, ax = plt.subplots(2, 2)\n# Note the use of `ravel` to create a 1D array:\nax[0, 0].hist(np.ravel(data))\nax[0, 0].set_xlabel(\"fMRI signal\")\nax[0, 0].set_ylabel(\"# voxels\")\n\n# Bars are 0.8 wide:\nax[0, 1].bar([0.6, 1.6, 2.6, 3.6], [np.mean(data[:, :, 15]), np.mean(data[:, :, 14]), np.mean(data[:, :, 13]), np.mean(data[:, :, 12])])\nax[0, 1].set_ylabel(\"Average signal in the slice\")\nax[0, 1].set_xticks([1,2,3,4])\nax[0, 1].set_xticklabels([\"15\", \"14\", \"13\", \"12\"])\nax[0, 1].set_xlabel(\"Slice #\")\n\n# Compares subsequent time-points:\nax[1, 0].scatter(data[:, :, 15, 0], data[:, :, 15, 1])\nax[1, 0].set_xlabel(\"fMRI signal (time-point 0)\")\nax[1, 0].set_ylabel(\"fMRI signal (time-point 1)\")\n\n# `.T` denotes a transposition\nax[1, 1].boxplot(data[32, 32].T)\nfig.set_size_inches([12, 12])\nax[1, 1].set_xlabel(\"Position\")\nax[1, 1].set_ylabel(\"fMRI signal\")",
"_____no_output_____"
]
],
[
[
"One way to learn more about all the different options available in Matplotlib is to visit the [gallery](http://matplotlib.org/gallery.html)",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
]
] |
ece9d2907cabd70bd6acc447f3a2ad9078a30a50 | 45,173 | ipynb | Jupyter Notebook | notebooks/seti_cnn_tf_training.ipynb | IBM/powerai_seti_signal_classification | e40b6064fd24ce146ef731bf9a0c0e76263fa61c | [
"Apache-2.0"
] | 16 | 2018-12-04T13:52:31.000Z | 2022-02-05T22:57:06.000Z | notebooks/seti_cnn_tf_training.ipynb | IBM/powerai_seti_signal_classification | e40b6064fd24ce146ef731bf9a0c0e76263fa61c | [
"Apache-2.0"
] | 1 | 2018-12-03T22:42:55.000Z | 2018-12-05T22:37:32.000Z | notebooks/seti_cnn_tf_training.ipynb | IBM/powerai_seti_signal_classification | e40b6064fd24ce146ef731bf9a0c0e76263fa61c | [
"Apache-2.0"
] | 10 | 2018-12-02T03:54:12.000Z | 2020-09-01T06:41:54.000Z | 34.668457 | 775 | 0.596418 | [
[
[
"<a href=\"https://www.bigdatauniversity.com\"><img src = \"https://ibm.box.com/shared/static/cw2c7r3o20w9zn8gkecaeyjhgw3xdgbj.png\" width = 200, align = \"left\"></a>\n<br>\n<br>\n\n--------------------\n# Search for Extra Terrestrial Intelligence (SETI)\n### SETI Signal Classification on PowerAI with Single GPU\n<hr>\n<br>",
"_____no_output_____"
],
[
"### Introduction\nIn this notebook, we will use the famous [SETI Dataset](https://github.com/setiQuest/ML4SETI/) to build a convolutional neural network (CNN) able to perform signal classification. The CNN will determine, with some associated error, what type of signal is presented.\n\n### Project overview\nEach night, using the Allen Telescope Array (ATA) in northern California, the SETI Institute scans the sky at various radio frequencies, observing star systems with known exoplanets, searching for faint but persistent signals. The current signal detection system is programmed to search only for particular kinds of signals: narrow-band carrier waves. However, the detection system sometimes triggers on signals that are not narrow-band signals (with unknown efficiency) and are also not explicitly-known radio frequency interference (RFI). Various categories of these kinds of events have been observed in the past.\n\nOur goal is to classify these accurately in real-time. This may allow the signal detection system to make better observational decisions, increase the efficiency of the nightly scans, and allow for explicit detection of these other signal types.\n\nFor more information refer to [SETI hackathon page](https://github.com/setiQuest/ML4SETI/).\n\n### Performance\nConvolutional neural networks involve a lot of matrix and vector multiplications that can be parallelized. GPUs can improve performance, because GPUs were designed to handle these operations in parallel!\n\n### GPU vs. CPU\nA single core CPU takes a matrix operation in serial, one element at a time, but a single GPU could have hundreds or thousands of cores, while a CPU typically has no more than a few cores.\n\n### How to use GPUs with TensorFlow?\nIt is important to notice that if both CPU and GPU are available on the machine that you are running the notebook, and if a TensorFlow operation has both CPU and GPU implementations, the GPU devices will be given priority when the operation is assigned to a device.\n\nIn our case, as we are running this notebook on [IBM PowerAI](http://cocl.us/SETI-NIMBIX-PowerAI), you may have access to multiple GPUs, but lets use one of the GPUs in this notebook, for the sake of simplicity.\n\n> Note: If you are running the **free trial**, you would expect to have zero GPUs. This notebook will work, but the training will be slow.",
"_____no_output_____"
]
],
[
[
"import sys\nsys.path.insert(0, \"/opt/DL/tensorflow/lib/python2.7/site-packages/\")\nimport requests\nimport json\nimport numpy as np\nimport matplotlib.pyplot as plt\nimport tensorflow as tf\nimport pickle\nimport time\nimport os\nfrom sklearn.metrics import confusion_matrix\nfrom sklearn import metrics\nfrom six.moves import urllib\nimport tarfile\nimport numpy as np\nfrom PIL import Image\nimport math\nimport datetime\n%matplotlib inline",
"_____no_output_____"
]
],
[
[
"### Set the parameters",
"_____no_output_____"
]
],
[
[
"### Set your working space here. Use this folder to save intermediate results.\ndataset_name = 'SETI_ds_64x128'\ndata_dir = \"tmp/SETI1_data/\"\ntrain_dir = 'tmp/SETI1_train/'\nlog_dir = train_dir + '1GPU_4'\n# check point directory\nchk_directory = train_dir + '/save1/'\ncheckpoint_path = chk_directory + 'model.ckpt'",
"_____no_output_____"
]
],
[
[
"### Create the necessary folders",
"_____no_output_____"
]
],
[
[
"if os.path.exists(data_dir) is False:\n os.makedirs(data_dir)\nprint data_dir\nprint os.popen(\"ls -lrt \"+ data_dir).read()\nif os.path.exists(train_dir) is False:\n os.makedirs(train_dir)\nprint train_dir",
"_____no_output_____"
]
],
[
[
"### Import the dataset reader\nThe signals have been converted into spectogram images and stored as 4 files.\nThe following cell will download and import python code to help us decode the binary files, and read the SETI dataset.",
"_____no_output_____"
]
],
[
[
"!wget -q --output-document SETI.zip https://ibm.box.com/shared/static/jhqdhcblhua5dx2t7ixwm88okitjrl6l.zip\n!unzip -o SETI.zip\nimport SETI",
"_____no_output_____"
]
],
[
[
"### Download data\nThe following cell downloads and extracts the dataset.",
"_____no_output_____"
]
],
[
[
"def maybe_download_and_extract():\n DATA_URL = 'https://ibm.box.com/shared/static/qz33lcio9ip2j8qi2atxqs62gn3bnu2s.gz'\n dest_directory = data_dir\n if not os.path.exists(dest_directory):\n os.makedirs(dest_directory)\n filename = DATA_URL.split('/')[-1]\n filepath = os.path.join(dest_directory, filename)\n if not os.path.exists(filepath):\n # print 'No zip file exists in ', filepath\n def _progress(count, block_size, total_size):\n sys.stdout.write('\\r>> Downloading %s %.1f%%' % (filename, float(count * block_size) / float(total_size) * 100.0))\n sys.stdout.flush()\n filepath, _ = urllib.request.urlretrieve(DATA_URL, filepath, _progress)\n\n statinfo = os.stat(filepath)\n print('Successfully downloaded', filename, statinfo.st_size, 'bytes.')\n extracted_dir_path = os.path.join(dest_directory, dataset_name)\n if not os.path.exists(extracted_dir_path):\n print 'Extracting to', extracted_dir_path\n tarfile.open(filepath, 'r:gz').extractall(dest_directory)\nmaybe_download_and_extract()",
"_____no_output_____"
]
],
[
[
"### Load data SETI",
"_____no_output_____"
]
],
[
[
"ds_directory = data_dir + dataset_name\ndataset = SETI.read_data_sets(ds_directory, one_hot=True, validation_size=0)\ndataset.train.images.shape",
"_____no_output_____"
]
],
[
[
"### Understanding the imported data\n\nThe imported data can be divided as follows:\n\n- Training (dataset.train) >> Use the given dataset with inputs and related outputs for training of NN. In our case, if you give an image that you know represents \"class1\", this set will tell the neural network that we expect \"class1\" as the output. \n - 694 signals (images)\n - dataset.train.images for inputs\n - dataset.train.labels for outputs\n \n \n- Test (mnist.test) >> The model does not have access to this information prior to the test phase. It is used to evaluate the performance and accuracy of the model against \"real life situations\". No further optimization beyond this point. \n - 10,000 data points\n - dataset.test.images for inputs\n - dataset.test.labels for outputs\n \n \n#### Labels\n- Each image (spectrum of signal) in the dataset has been labeled from 1 to 4, representing:\n - squiggle\n - narrowband\n - noise\n - narrowbanddrd",
"_____no_output_____"
],
[
"## Network parameters",
"_____no_output_____"
]
],
[
[
"# Parameters\ndecay_rate=0.96\ndecay_steps=500\nlearning_rate = 0.005\ntraining_epochs = 50\nbatch_size = 128\ndisplay_step = 1\n\nn_classes = 4 # number of possible classifications for the problem\ndropout = 0.60 # Dropout, probability to keep units\n\nheight = 64 # height of the image in pixels \nwidth = 128 # width of the image in pixels \nn_input = width * height # number of pixels in one image \n",
"_____no_output_____"
]
],
[
[
"### Inputs\n\nIt's a best practice to create placeholders before variable assignments when using TensorFlow. Here we'll create placeholders for inputs (\"x\") and outputs (\"y_\"). \n\n__Placeholder 'x':__ represents the \"space\" allocated input or the images. \n * Each input has 8192 pixels distributed by a 64 width x 128 height matrix.\n * The 'shape' argument defines the tensor size by its dimensions.\n * 1st dimension = None. Indicates that the batch size can be of any size.\n * 2nd dimension = 8192. Indicates the number of pixels on a single flattened spectogram image.\n \n__Placeholder 'y_':__ represents the final output or the labels.\n * 4 possible classes (0,1,2,3).\n * The 'shape' argument defines the tensor size by its dimensions.\n * 1st dimension = None. Indicates that the batch size can be of any size.\n * 2nd dimension = 4. Indicates the number of targets/outcomes.\n\n__dtype for both placeholders:__ If you are not sure, use tf.float32. The limitation here is that the later presented softmax function only accepts float32 or float64 dtypes. For more dtypes, check TensorFlow's documentation <a href=\"https://www.tensorflow.org/versions/r0.9/api_docs/python/framework.html#tensor-types\">here</a>",
"_____no_output_____"
]
],
[
[
"x = tf.placeholder(tf.float32, shape=[None, n_input], name = 'x')\ny_ = tf.placeholder(tf.float32, shape=[None, n_classes], name = 'y_')",
"_____no_output_____"
]
],
[
[
"The input image is a 64 pixels by 128 pixels, 1 channel (grayscale). In this case, the first dimension is the __batch number__ of the image and can be of any size (so we set it to -1). The second and third dimensions are width and height. The last one is the image channels.",
"_____no_output_____"
]
],
[
[
"x_image = tf.reshape(x, [-1,height,width,1]) ",
"_____no_output_____"
]
],
[
[
"### Convolutional neural networks (CNNs)\n\nConvolutional neural networks (CNNs) are a type of feed-forward neural network, consisting of multiple layers of neurons that have learnable weights and biases. Each neuron in a layer that receives some input, processes it, and optionally follows it with non-linearity. The network has multiple layers such as convolution, max pool, drop out and fully connected layers. In each layer, small neurons process portions of the input image. The outputs of these collections are then tiled, so that their input regions overlap, to obtain a higher-resolution representation of the original image. This is repeated for every such layer. The important point here is: CNNs are able to break the complex patterns down into a series of simpler patterns, through multiple layers.\n\n### CNN architecture\nNow we are going to use a Deep Neural Network. \n\nArchitecture of our network is:\n \n- [Input] >>>> (batch_size, 64, 128, 1) \n- [Convolutional layer 1] >>>> (batch_size, 64, 128, 32)\n- [ReLU 1] >>>> (batch_size, 64, 128, 32)\n- [Max pooling 1] >>>> (batch_size, 32, 64, 32)\n- [Convolutional layer 2] >>>> (batch_size, 32, 64, 64)\n- [ReLU 2] >>>> (batch_size, 32, 64, 64)\n- [Max pooling 2] >>>> (batch_size, 8, 16, 64) \n- [fully connected layer 1] >>>> (batch_size, 1024)\n- [ReLU] >>>> (batch_size, 1024)\n- [Drop out] >>>> (batch_size, 1024)\n- [Readout layer] >>>> (batch_size, 1024)\n",
"_____no_output_____"
],
[
"#### Convolutional Layer 1\nWe define a kernel here. The size of the filter/kernel is 5x5; Input channels is 1 (greyscale); and we need 32 different feature maps (here, 32 feature maps means 32 different filters are applied on each image. So, the output of the convolution layer would be 64x128x32). In this step, we create a filter / kernel tensor of shape `[filter_height, filter_width, in_channels, out_channels]`.\n\n- To create a convolutional layer, we use __tf.nn.conv2d__. It computes a 2-D convolution given 4-D input and filter tensors.\n- The convolutional layer slides the \"kernel window\" across the input tensor. As the input tensor has 4 dimensions: [batch, height, width, channels], then the convolution operates on a 2D window on the height and width dimensions. __strides__ determines how much the window shifts in each of the dimensions. As the first and last dimensions are related to batch and channels, we set the stride to 1. But for second and third dimension, we could set other values, e.g. [1, 2, 2, 1]\n- __max pooling__ is a form of non-linear down-sampling. It partitions the input image into a set of rectangles and, and then finds the maximum value for that region. Let's use __tf.nn.max_pool__ function to perform max pooling. ",
"_____no_output_____"
]
],
[
[
"with tf.variable_scope('layer1') as scope:\n W_conv1 = tf.get_variable( initializer= tf.truncated_normal([5, 5, 1, 32], stddev=0.1), name= 'w1')\n b_conv1 = tf.get_variable(initializer=tf.constant(0.1, shape=[32]), name='b1') # need 32 biases for 32 outputs\n convolve1 = tf.nn.conv2d(x_image, W_conv1, strides=[1, 1, 1, 1], padding='SAME', name='convolv1') + b_conv1\n h_conv1 = tf.nn.relu(convolve1, name='relu1')\n conv1 = tf.nn.max_pool(h_conv1, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME', name='pool1') # max_pool_2x2",
"_____no_output_____"
]
],
[
[
"#### Convolutional Layer 2\nWe apply the convolution again in this layer. Let's look at the second layer kernel: \n- Filter/kernel: 5x5x32\n- Input channels: 32 (from the 1st Conv layer, we had 32 feature maps), so we use 64 output feature maps ",
"_____no_output_____"
]
],
[
[
"with tf.variable_scope('layer2') as scope:\n W_conv2 = tf.get_variable(initializer=tf.truncated_normal([5, 5, 32, 64], stddev=0.1), name= 'w2')\n b_conv2 = tf.get_variable(initializer=tf.constant(0.1, shape=[64]), name= 'b2') # need 64 biases for 64 outputs\n convolve2= tf.nn.conv2d(conv1, W_conv2, strides=[1, 1, 1, 1], padding='SAME', name='convolv2')+ b_conv2\n h_conv2 = tf.nn.relu(convolve2, name='relu2')\n conv2 = tf.nn.max_pool(h_conv2, ksize=[1, 2, 2, 1], strides=[1, 4, 4, 1], padding='SAME', name='pool2') # max_pool_2x2",
"_____no_output_____"
]
],
[
[
"#### Fully Connected Layer\n\nYou need a fully connected layer to use the Softmax and create the probabilities in the end. Fully connected layers take the high-level filtered images from the previous layer, that is all 64 metrics, and converts them to a flat array.\n\nSo, the matrix (8x16)x64 will be converted to a matrix of size (1x1024).",
"_____no_output_____"
]
],
[
[
"dim = conv2.get_shape().as_list()\ndims = dim[1]*dim[2]*dim[3]\nnodes1 = 1024\nwith tf.variable_scope('FullyCon1') as scope:\n prv_layer_matrix = tf.reshape(conv2, [-1, dims], name='rshaped_inp')\n W_fc1 = tf.get_variable(initializer= tf.truncated_normal([dims, nodes1], stddev=0.1), name='W_FC1')\n b_fc1 = tf.get_variable(initializer= tf.constant(0.1, shape=[nodes1]), name='b_FC1') # need 1024 biases for 1024 outputs\n h_fcl1 = tf.matmul(prv_layer_matrix, W_fc1) + b_fc1\n fc_layer1 = tf.nn.relu(h_fcl1, name='relu_FC1') ",
"_____no_output_____"
]
],
[
[
"#### Droupout 1\nThis is a phase where the network \"forgets\" some features. At each training step in a mini-batch, some units get switched off randomly so that they will not interact with the network. That is, its weights cannot be updated, nor affect the learning of the other network nodes. This can be very useful for very large neural networks to prevent overfitting.",
"_____no_output_____"
]
],
[
[
"keep_prob = tf.placeholder(tf.float32, name= 'keep_prob')\nlayer_drop1 = tf.nn.dropout(fc_layer1, keep_prob, name='dropout')",
"_____no_output_____"
]
],
[
[
"#### Readout Layer\nIn the last layer, CNN takes the high-level filtered images and translates them into votes using softmax. __softmax__ allows us to interpret the outputs of __fcl4__ as probabilities. So, __y_conv__ is a tensor of probabilities.\nInput channels in this layer is 1024 (neurons from the 3rd layer) pixels, and output features are 4 classes. ",
"_____no_output_____"
]
],
[
[
"with tf.variable_scope('ReadoutLayer') as scope:\n W_fc = tf.get_variable(initializer = tf.truncated_normal([nodes1, n_classes], stddev=0.1), name ='W_FC2') # 1024 neurons\n b_fc = tf.get_variable(initializer =tf.constant(0.1, shape=[n_classes]), name = 'b_FC2') # 10 possibilities for classes [0,1,2,3]\n fc = tf.matmul(layer_drop1, W_fc) + b_fc\n y_CNN = tf.nn.softmax(fc, name = 'softmax_linear')",
"_____no_output_____"
]
],
[
[
"#### Loss function\nWe need to compare our output, layer4 tensor, with ground truth for all mini_batch. We can use __cross entropy__ to see how bad our CNN is working - to measure the error at a softmax layer. __softmax_cross_entropy_with_logits__ \ncomputes softmax cross entropy between logits and labels, and __reduce_mean__ computes the mean of all elements in the tensor.",
"_____no_output_____"
]
],
[
[
"with tf.name_scope('cross_entropy'):\n cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=y_CNN, labels=y_))\n tf.summary.scalar('cross_entropy', cross_entropy)",
"_____no_output_____"
]
],
[
[
"#### Training\nIt is obvious that we want to minimize the error of our network which is calculated by the cross_entropy metric. To solve the problem, we have to compute gradients for the loss (which is minimizing the cross-entropy) and apply gradients to variables. This will be done by an optimizer: GradientDescent. ",
"_____no_output_____"
]
],
[
[
"# Create a variable to track the global step.\nglobal_step = tf.Variable(0, trainable=False)\n\n# create learning_decay\nlr = tf.train.exponential_decay( learning_rate,\n global_step,\n decay_steps,\n decay_rate, staircase=True )\ntf.summary.scalar('learning_rate', lr)",
"_____no_output_____"
],
[
"# Use the optimizer to apply the gradients that minimize the loss\n# (and also increment the global step counter) as a single training step.\n\nwith tf.name_scope('train'):\n optimizer = tf.train.GradientDescentOptimizer(lr)\n train_op = optimizer.minimize(cross_entropy, global_step=global_step)",
"_____no_output_____"
]
],
[
[
"#### Evaluation\nDo you want to know how many of the cases in a mini-batch have been classified correctly? Let's count them.",
"_____no_output_____"
]
],
[
[
"with tf.name_scope('accuracy_all'):\n pred_lb = tf.argmax(y_CNN,1)\n true_lb = tf.argmax(y_,1)\n correct_prediction = tf.equal(pred_lb,true_lb )\n accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))\n tf.summary.scalar('accuracy', accuracy)",
"_____no_output_____"
],
[
"# Calculate accuracy for test images\ndef evaluate():\n with tf.variable_scope(tf.get_variable_scope()):\n num_iter = int(math.ceil(dataset.test.num_examples / batch_size))\n true_count = 0 # Counts the number of correct predictions.\n total_sample_count = num_iter * batch_size\n step = 0\n while step < num_iter:\n x_batch, y_batch = dataset.test.next_batch(batch_size)\n predictions = sess.run([correct_prediction], feed_dict={x: x_batch, y_: y_batch, keep_prob: 1.})\n true_count += np.sum(predictions)\n step += 1\n\n precision = true_count*1.0 / total_sample_count\n tf.summary.scalar('precision', precision)\n return precision",
"_____no_output_____"
]
],
[
[
"### Create checkpoint directory",
"_____no_output_____"
]
],
[
[
"directory = os.path.dirname(chk_directory)\ntry:\n os.stat(directory)\n ckpt = tf.train.get_checkpoint_state(chk_directory)\n print ckpt\nexcept:\n os.mkdir(directory) ",
"_____no_output_____"
]
],
[
[
"<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 20px\">\n<font size = 3><strong>*You can run this cell if you REALLY have time to wait, or you are running it using PowerAI </strong></font>\n<br>\n\n<b> What is PowerAI? </b>\n\nRunning deep learning programs usually needs a high performance platform. PowerAI speeds up deep learning and AI. Built on IBM's Power Systems, PowerAI is a scalable software platform that accelerates deep learning and AI with blazing performance for individual users or enterprises. The PowerAI platform supports popular machine learning libraries and dependencies including Tensorflow, Caffe, Torch, and Theano. You can download a [free version of PowerAI](https://cocl.us/DX0108EN-PowerAI).\n\n<br>\n__Notice:__ If you are running this notebook on PowerAI, it will automatically run on a GPU, otherwise it will use a CPU. Also, you can change the number of epochs to gain a higher accuracy.\n</div>",
"_____no_output_____"
],
[
"## Training",
"_____no_output_____"
]
],
[
[
"num_examples = dataset.train.num_examples\ntotal_batch = int(num_examples / batch_size)\nprint 'Training dataset size:',num_examples, ' Signals'\nprint 'Testing dataset size:',dataset.test.num_examples, ' Signals'\nprint 'Total epochs:', training_epochs\nprint 'Total steps:', training_epochs * total_batch\nprint 'Batch size:', batch_size\nprint 'Total batchs per epoch:',total_batch\nprint str(datetime.datetime.now())\n# Initializing the variables\ninit = tf.global_variables_initializer()\nloss_values = []\nsess = tf.Session(config=tf.ConfigProto(allow_soft_placement=True))\nsess.run(init)\n\nmerged = tf.summary.merge_all()\ntrain_writer = tf.summary.FileWriter(log_dir, sess.graph)\n \nX_test = dataset.test.images\ny_test = dataset.test.labels\nsess.run(init)\nsaver = tf.train.Saver(tf.global_variables())\n\n# load previously trained model if appilcable\nckpt = tf.train.get_checkpoint_state(chk_directory)\nif ckpt:\n print (\"loading model: \",ckpt.model_checkpoint_path)\n # saver.restore(sess, ckpt.model_checkpoint_path)\n\n# Training cycle\ntr_start = time.time()\nfor epoch in range(training_epochs):\n avg_loss = 0.\n avg_train_acc = 0.\n total_batch = int(num_examples / batch_size)\n\n # Loop over all batches\n start = time.time()\n for step in range(total_batch):\n x_batch, y_batch = dataset.train.next_batch(batch_size ,shuffle=True)\n b_start_time = time.time()\n loss, acc = sess.run([cross_entropy, accuracy], feed_dict={x: x_batch,y_: y_batch,keep_prob: 1.})\n sess.run(train_op,feed_dict={x: x_batch, y_: y_batch, keep_prob: dropout})\n b_end_time = time.time() - b_start_time\n avg_loss += loss / total_batch\n avg_train_acc += acc / total_batch\n \n \n # save model every x epochs\n if epoch >= 0 and epoch % 50 == 0:\n # Save model\n # print (\"model saved to {}\".format(checkpoint_path))\n saver.save(sess, checkpoint_path, global_step = epoch)\n \n \n ## Display model every 1 epochs\n if epoch >= 0 and epoch % display_step == 0:\n end = time.time()\n plr = sess.run(lr)\n loss_values.append(avg_loss) \n test_acc = evaluate()\n print(\"Epoch:\"+ '%04d' % (epoch+1) + \\\n \", Ep_time=\" + \"{:.2f}\".format(end - start) + \\\n \", lr=\" + \"{:.9f}\".format(plr) + \\\n \", avg_cost=\" + \"{:.3f}\".format(avg_loss) + \\\n \", Train_Acc=\" + \"{:.2f}\".format(avg_train_acc) + \\\n \", Test_Acc=\" + \"{:.2f}\".format(test_acc) + \n \", Batch (sec)=\" + \"{:.3f}\".format(b_end_time) ) \n \n # Summarize model every x epochs\n if epoch >= 0 and epoch % 1 == 0: \n summary= sess.run(merged,feed_dict={x: x_batch,y_: y_batch,keep_prob: 1.})\n train_writer.add_summary(summary, epoch)\nprint(\"Wall Time:\",\"{:.1f}\".format((time.time() - tr_start)/60.0, \"Min\")) \nprint(\"Optimization Finished!\")\nprint (\"model saved to {}\".format(checkpoint_path))\nsaver.save(sess, checkpoint_path, global_step = (epoch+1)*step)\ntrain_writer.close()",
"_____no_output_____"
],
[
"# Find the labels of test set\ny_pred_lb = sess.run(tf.argmax(y_CNN,1), feed_dict={x: X_test, y_: y_test, keep_prob: 1.})\ny_pred = sess.run(y_CNN, feed_dict={x: X_test, y_: y_test, keep_prob: 1.})\n\n# lets save kernels\nkernels_l1 = sess.run(tf.reshape(tf.transpose(W_conv1, perm=[2, 3, 0, 1]),[32,-1]))\nkernels_l2 = sess.run(tf.reshape(tf.transpose(W_conv2, perm=[2, 3, 0, 1]),[32*64,-1]))",
"_____no_output_____"
],
[
"plt.plot([np.mean(loss_values[i:i+5]) for i in range(len(loss_values))])\nplt.show()",
"_____no_output_____"
]
],
[
[
"## Evaluation",
"_____no_output_____"
],
[
"Accuracy depends on the number of epochs that you set in the parameters part.",
"_____no_output_____"
]
],
[
[
"y_ = np.argmax(y_test,1) # ground truth\nprint metrics.classification_report(y_true= y_, y_pred= y_pred_lb)\nprint metrics.confusion_matrix(y_true= y_, y_pred= y_pred_lb)\nprint(\"Classification accuracy: %0.6f\" % metrics.accuracy_score(y_true= y_, y_pred= y_pred_lb) )\nprint(\"Log Loss: %0.6f\" % metrics.log_loss(y_true= y_, y_pred= y_pred) )",
"_____no_output_____"
]
],
[
[
"### Viz\nDo you want to look at all the filters? Let's use __utils__ to visualize them.",
"_____no_output_____"
]
],
[
[
"!wget --output-document utils1.py http://deeplearning.net/tutorial/code/utils.py\nimport utils1\nfrom utils1 import tile_raster_images",
"_____no_output_____"
]
],
[
[
"Here you can plot the 32 filters in the first convolutional layer.",
"_____no_output_____"
]
],
[
[
"image = Image.fromarray(tile_raster_images(kernels_l1, img_shape=(5, 5) ,tile_shape=(4, 8), tile_spacing=(1, 1)))\n### Plot image\nplt.rcParams['figure.figsize'] = (18.0, 18.0)\nimgplot = plt.imshow(image)\nimgplot.set_cmap('gray') ",
"_____no_output_____"
]
],
[
[
"Also, you can plot and take a look at some filters from the second convolutional layers:",
"_____no_output_____"
]
],
[
[
"image = Image.fromarray(tile_raster_images(kernels_l2, img_shape=(5, 5) ,tile_shape=(4, 12), tile_spacing=(1, 1)))\n### Plot image\nplt.rcParams['figure.figsize'] = (18.0, 18.0)\nimgplot = plt.imshow(image)\nimgplot.set_cmap('gray') ",
"_____no_output_____"
]
],
[
[
"To understand better, let's apply one of these filters on a sample signal (spectogram image). First, let's plot a sample spectogram:",
"_____no_output_____"
]
],
[
[
"plt.rcParams['figure.figsize'] = (5.0, 5.0)\nsampleimage1 = X_test[3]\nplt.imshow(np.reshape(sampleimage1,[64,128]), cmap=\"gray\")",
"_____no_output_____"
]
],
[
[
"Now we apply different filters on them, and plot the result:",
"_____no_output_____"
]
],
[
[
"# Launch the graph\nwith tf.Session() as sess:\n sess.run(init)\n saver = tf.train.Saver(tf.all_variables())\n \n # load previously trained model if appilcable\n ckpt = tf.train.get_checkpoint_state(chk_directory)\n if ckpt:\n print \"loading model: \",ckpt.model_checkpoint_path\n saver.restore(sess, ckpt.model_checkpoint_path)\n ActivatedUnits1 = sess.run(convolve1,feed_dict={x:np.reshape(sampleimage1,[1,64*128],order='F'),keep_prob:1.0})\n plt.figure(1, figsize=(20,20))\n n_columns = 3\n n_rows = 3\n for i in range(9):\n plt.subplot(n_rows, n_columns, i+1)\n plt.title('Filter ' + str(i))\n plt.imshow(ActivatedUnits1[0,:,:,i], interpolation=\"nearest\", cmap=\"gray\")",
"_____no_output_____"
]
],
[
[
"### Benchmark:\n- SETI_multi_gpu_train.py achieves ~72% accuracy after 3k epochs of data (75K steps).\n- Speed: With batch_size 128. \n- __Notice:__ The model is not optimized to reach its highest accuracy. You can achieve better results by tuning the parameters.\n\n<table border=\"1\" style=\"box-sizing: border-box; border-spacing: 30px; background-color: transparent; color: #333333; font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif; font-size: 12px;\">\n<tbody style=\"box-sizing: border-box;\">\n<tr style=\"box-sizing: border-box;\">\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\"><span style=\"box-sizing: border-box; font-weight: bold;\">CPU Architecture</span></td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\"><span style=\"box-sizing: border-box; font-weight: bold;\">CPU cores </span></td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\"><span style=\"box-sizing: border-box; font-weight: bold;\">Memory </span></td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\"><span style=\"box-sizing: border-box; font-weight: bold;\">GPU </span></td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\"><span style=\"box-sizing: border-box; font-weight: bold;\">Step time (sec/batch) </span></td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\"><span style=\"box-sizing: border-box; font-weight: bold;\"> Accuracy</span></td>\n</tr>\n<tr style=\"box-sizing: border-box;\">\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\">POWER8</td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:center;\">40</td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:center;\">256 GB</td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\">1 x Tesla K80</td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:center;\">~0.127 </td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\">~72% at 75K steps (3 hours)</td>\n</tr>\n<tr style=\"box-sizing: border-box;\">\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\" >POWER8</td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:center;\">32</td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:center;\">128 GB</td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\">1 x Tesla P100 w/NVLink np8g4</td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:center;\">~0.035 </td>\n<td style=\"box-sizing: border-box; padding: 3px; text-align:left;\">~72% at 75K steps (1 hour)</td>\n</tr>\n\n\n</tbody>\n</table>\n\n\n",
"_____no_output_____"
],
[
"## Want to learn more?\n\n[Deep Learning with TensorFlow](https://cocl.us/SETI_CodePattern_ML0120EN) is a free course in __cognitiveclass.ia__ where you can learn TensorFlow and Deep Learning together.\n\nRunning deep learning programs usually needs a high performance platform. PowerAI speeds up deep learning and AI. Built on IBM's Power Systems, PowerAI is a scalable software platform that accelerates deep learning and AI with blazing performance for individual users or enterprises. The PowerAI platform supports popular machine learning libraries and dependencies including Tensorflow, Caffe, Torch, and Theano. You can use [PowerAI on IBM Cloud](https://cocl.us/ML0120EN_PAI).",
"_____no_output_____"
],
[
"### Authors\n\n<div class=\"teacher-image\" style=\" float: left;\n width: 115px;\n height: 115px;\n margin-right: 10px;\n margin-bottom: 10px;\n border: 1px solid #CCC;\n padding: 3px;\n border-radius: 3px;\n text-align: center;\"><img class=\"alignnone wp-image-2258 \" src=\"https://ibm.box.com/shared/static/tyd41rlrnmfrrk78jx521eb73fljwvv0.jpg\" alt=\"Saeed Aghabozorgi\" width=\"178\" height=\"178\" /></div>\n\n#### Saeed Aghabozorgi\n\n[Saeed Aghabozorgi](https://ca.linkedin.com/in/saeedaghabozorgi), PhD is Sr. Data Scientist in IBM with a track record of developing enterprise level applications that substantially increases clients’ ability to turn data into actionable knowledge. He is a researcher in data mining field and expert in developing advanced analytic methods like machine learning and statistical modelling on large datasets.</p>\n\n\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"
] | [
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
]
] |
ece9ddd08cec906df591192965d45f3c363588d2 | 111,668 | ipynb | Jupyter Notebook | nb/PyIntro.ipynb | sybenzvi/PHY403 | 159f1203b5fc92ffc1f2b7dc9fef3c2f78207dd7 | [
"BSD-3-Clause"
] | 3 | 2020-05-27T23:51:39.000Z | 2021-02-03T03:34:53.000Z | nb/PyIntro.ipynb | sybenzvi/PHY403 | 159f1203b5fc92ffc1f2b7dc9fef3c2f78207dd7 | [
"BSD-3-Clause"
] | null | null | null | nb/PyIntro.ipynb | sybenzvi/PHY403 | 159f1203b5fc92ffc1f2b7dc9fef3c2f78207dd7 | [
"BSD-3-Clause"
] | 7 | 2020-05-06T16:01:09.000Z | 2022-02-04T18:47:26.000Z | 43.131711 | 23,476 | 0.690251 | [
[
[
"# Basic Introduction to Python\n\nThis is a very basic introduction to Python. It is not exhaustive, but is meant to give you a starting point.\n\nThis notebook was written for PHY 403 by Segev BenZvi, University of Rochester, (Spring 2021).\n\nIt is based on a similar (longer) Python guide written by Kyle Jero (UW-Madison) for the IceCube Programming Bootcamp in June 2015, and includes elements from older guides by Jakob van Santen and Nathan Whitehorn.\n\n\n## What is Python?\n\nPython is an **imperative**, **interpreted** programming language with **strong** **dynamic** typing.\n\n- **Imperative**: programs are built around one or more subroutines known as \"functions\" and \"classes\"\n- **Interpreted**: program instructions are executed on the fly rather than being pre-compiled into machine code\n- **Dynamic Typing**: data types of *variables* (`int`, `float`, `string`, etc.) are determined on the fly as the program runs\n- **Strong Typing**: converting a variable from one type to another (e.g., `int` to `string`) is not always done automatically\n\nPython offers fast and flexible development and can be used to glue together many different analysis packages which have \"Python bindings.\"\n\nAs a rule, Python programs are slower than compiled programs written in Fortran, C, and C++. But it's a much more forgiving programming language.\n\n## Why Use Python?\n\nPython is one of the most popular scripting languages in the world, with a huge community of users and support on all major platforms (Windows, OS X, Linux).\n\n\n\n\n\nPretty much every time I've run into a problem programming in Python, I've found a solution after a couple of minutes of searching on google or stackoverflow.com!\n\n## Key Third-Party Packages\n\n### Must-Haves\n\n- <a href=\"http://www.numpy.org/\">NumPy</a>: random number generation, transcendental functions, vectorized math, linear algebra.\n- <a href=\"http://www.scipy.org/\">SciPy</a>: statistical tests, special functions, numerical integration, curve fitting and minimization.\n- <a href=\"http://matplotlib.org/\">Matplotlib</a>: plotting: xy plots, error bars, contour plots, histograms, etc.\n- <a href=\"http://ipython.org/\">IPython</a>: an interactive python shell, which can be used to run Mathematica-style analysis notebooks.\n\n### Worth Using\n\n- <a href=\"https://scikits.appspot.com/\">SciKits</a>: data analysis add-ons to SciPy, including machine learning algorithms.\n- <a href=\"http://pandas.pydata.org/\">Pandas</a>: functions and classes for specialized data analysis.\n- <a href=\"http://www.astropy.org/\">AstroPy</a>: statistical methods useful for time series analysis and data reduction in astronomy.\n- <a href=\"http://dan.iel.fm/emcee/current/\">Emcee</a>: great implementation of Markov Chain Monte Carlo; nice to combine with the package <a href=\"https://pypi.python.org/pypi/corner\">Corner</a>.\n- <a href=\"https://pytorch.org/\">PyTorch</a>: currently the most popular deep learning framework.\n\n### Specialized Bindings\n\nMany C and C++ packages used in high energy physics come with bindings to Python. For example, the <a href=\"https://root.cern.ch/\">ROOT</a> package distributed by CERN can be run completely from Python.\n\n### Online Tools\n\nIf you don't want to install all these packages on your own computer, you can create a free account with many cloud services:\n- <a href=\"https://colab.research.google.com/\">Google Colab</a>\n- <a href=\"https://mybinder.org/\">Binder</a>\n- <a href=\"https://www.kaggle.com/\">Kaggle</a>\n- <a href=\"https://notebooks.azure.com\">Microsoft Azure</a>\n- <a href=\"https://cocalc.com/\">CoCalc</a>\n- <a href=\"https://datalore.io/\">Datalore</a>\n\nThe screen capture below shows an Azure notebook.\n\n\n\nAzure gives you access to jupyter notebooks running on remote servers. Recent versions of SciPy, NumPy, and Matplotlib are provided.\n\n## Programming Basics\n\nWe will go through the following topics, and then do some simple exercises.\n\n- Arithmetic Operators\n- Variables and Lists\n- Conditional Statements\n- Loops (`for` and `while`)\n- Functions\n- Importing Modules",
"_____no_output_____"
],
[
"### Arithmetic Operators",
"_____no_output_____"
],
[
"#### Addition",
"_____no_output_____"
]
],
[
[
"1+2",
"_____no_output_____"
]
],
[
[
"#### Subtraction",
"_____no_output_____"
]
],
[
[
"19993 - 7743",
"_____no_output_____"
]
],
[
[
"#### Multiplication",
"_____no_output_____"
]
],
[
[
"3*8",
"_____no_output_____"
]
],
[
[
"#### Division",
"_____no_output_____"
]
],
[
[
"50 / 2",
"_____no_output_____"
],
[
"1 / 3",
"_____no_output_____"
]
],
[
[
"Note: in Python 2, division of two integers is always **floor division**. In Python 3, 1/2 automatically evaluates to the *floating point number* 0.5. To use floor division in Python 3, you'll have to run `1 // 2`.",
"_____no_output_____"
]
],
[
[
"1 // 2 # floor division: will give you zero (int), not 0.5 (float)",
"_____no_output_____"
]
],
[
[
"#### Modulo/Remainder",
"_____no_output_____"
]
],
[
[
"30 % 4",
"_____no_output_____"
],
[
"3.14159265359 % 1.",
"_____no_output_____"
]
],
[
[
"#### Exponentiation",
"_____no_output_____"
]
],
[
[
"4**2",
"_____no_output_____"
]
],
[
[
"### Variables\n\nVariables are extremely useful for storing values and using them later. One can declare a variable to contain the output of any variable, function call, etc. However, variable names must follow certain rules:\n\n1. Variable names must start with a letter (upper or lower case) or underscore\n2. Variable names may contain only letters, numbers, and underscores _\n3. The following names are **reserved keywords** in Python and cannot be used as variable names:\n\n ` and del from not while`\n\n ` as elif global or with`\n \n ` assert else if pass yield`\n \n ` break except import print`\n \n ` class exec in raise`\n \n ` continue finally is return`\n \n ` def for lambda try`",
"_____no_output_____"
]
],
[
[
"x = 5 + 6",
"_____no_output_____"
]
],
[
[
"This time nothing printed out because the output of the expression was stored in the variable `x`. To see the value we have to just evaluate `x` in a cell...",
"_____no_output_____"
]
],
[
[
"x",
"_____no_output_____"
]
],
[
[
"...or we explicitly call the `print` function:",
"_____no_output_____"
]
],
[
[
"print(x)",
"11\n"
]
],
[
[
"Recall that we don't have to explicitly declare what type something is in python, something that is not true in many other languages, we simply have to name our variable and specify what we want it to store. However, it is still nice to know the types of things sometimes and learn what types python has available for our use.",
"_____no_output_____"
],
[
"#### Data Types",
"_____no_output_____"
]
],
[
[
"type(x)",
"_____no_output_____"
],
[
"y = 2\ntype(x/y)",
"_____no_output_____"
],
[
"z = 1.\ntype(z/y)",
"_____no_output_____"
],
[
"w = True\ntype(w)",
"_____no_output_____"
],
[
"h = 'Hello'\ntype(h)",
"_____no_output_____"
]
],
[
[
"##### Strings",
"_____no_output_____"
],
[
"Strings are collections of characters between pairs of single or double quotes. (Note: in other languages like C/C++, Java, etc., you must use double quotes for strings.) The ability to mix/match single and double quote pairs makes it easy to put a literal quotation mark inside a string. That is, the quotation mark won't be treated as a delimiting character that indicates the start or end of a string.\n\nString manipulation is an important part of managing certain kinds of data, such as records in text files. Python lets you do nice things like combine strings using simple arithmetic operators.",
"_____no_output_____"
]
],
[
[
"s = \" \" # Create a string with double quotes.\nw = 'World!' # Create a string with single quotes.\n\nprint(h + s + w) # Concatenate strings with + and print the result.",
"Hello World!\n"
],
[
"mystring1 = 'mystring1'\nmystring2 = \"mystring2\"\n\napostrophes=\"They're \"\nquotes='\"hypothetically\" ' # Add literal \" marks inside the string.\nsaying=apostrophes + quotes + \"good for you to know.\"\n\nprint(saying)",
"They're \"hypothetically\" good for you to know.\n"
]
],
[
[
"C-style formatted printing is also allowed:",
"_____no_output_____"
]
],
[
[
"p = 'Pi'\nprint('%s = %.3f' % (p, 3.14159265359)) # old-style string formatting\nprint('{:s} = {:.6f}'.format(p, 3.14159265359)) # new-style string formatting",
"Pi = 3.142\nPi = 3.141593\n"
]
],
[
[
"### Lists\n\nImagine that we are storing the heights of people or the results of a random process. We could imagine taking and making a new variable for each piece of information but this becomes convoluted very quickly. In instances like this it is best to store the collection of information together in one place. In python this collection is called a list and can be defined by enclosing data separated by commas in square brackets. A empty list can also be specified by square brackets with nothing between them and filled later in the program.",
"_____no_output_____"
]
],
[
[
"blanklist = []\nblanklist",
"_____no_output_____"
],
[
"alist=[1, 2.5, '3']\nprint(alist)\nprint(type(alist))",
"[1, 2.5, '3']\n<class 'list'>\n"
]
],
[
[
"Notice that the type of our list is `list` and no mention of the data type it contains is made. This is because python does not fuss about what type of thing is in a list or even mixing of types in lists. If you have worked with nearly any other language this is different then you are used to since the type of your list must be homogeneous.",
"_____no_output_____"
]
],
[
[
"blist=[1, 'two', 3.0]\nblist",
"_____no_output_____"
],
[
"print(type(blist))",
"<class 'list'>\n"
]
],
[
[
"You can check the current length of a list by calling the `len` function with the list as the argument:",
"_____no_output_____"
]
],
[
[
"len(blist)",
"_____no_output_____"
]
],
[
[
"In addition, you can add objects to the list or remove them from the list in several ways:",
"_____no_output_____"
]
],
[
[
"blist.append(\"4\") # Add the string '4' to the end.\nblist",
"_____no_output_____"
],
[
"blist.insert(0, \"0\") # Add the string '0' before the first element.\nblist",
"_____no_output_____"
],
[
"blist.extend([5,6]) # Insert one list into another.\nprint(blist)\nprint(len(blist))",
"['0', 1, 'two', 3.0, '4', 5, 6]\n7\n"
],
[
"blist.append(7)\nblist",
"_____no_output_____"
],
[
"# Multiplication doubles the elements in the list (not term-by-term multiplication).\n\nblist = blist*2\nblist",
"_____no_output_____"
],
[
"# Search for and remove the first element matching '4'.\n\nblist.remove(\"4\")\nblist",
"_____no_output_____"
],
[
"# Search for and remove the first element matching '4'.\n# There are now no '4' elements left.\n\nblist.remove('4')\nblist",
"_____no_output_____"
]
],
[
[
"##### List Element Access\n\nIndividual elements (or ranges of elements) in the list can be accessed using the square bracket operators [ ]. For example:",
"_____no_output_____"
]
],
[
[
"# Access elements with respect to the front of the list.\n# The first element has index 0.\n\nprint(blist[0])\nprint(blist[4])",
"0\n5\n"
],
[
"# Access elements with respect to the end of the list.\n# The last element has index -1.\n\nprint(blist[-1])\nprint(blist[-2])\nprint(blist[-3])",
"7\n6\n5\n"
],
[
"blist[0:4]",
"_____no_output_____"
],
[
"print(blist) # list slicing example:\nblist[0:6:2] # sytax: start, stop, stride",
"['0', 1, 'two', 3.0, 5, 6, 7, '0', 1, 'two', 3.0, 5, 6, 7]\n"
]
],
[
[
"This is an example of a slice, where we grab a subset of the list and also decide to step through the list by skipping every other element. The syntax is\n\n`listname[start:stop:stride]`\n\nNote that if start and stop are left blank, the full list is used in the slice by default.",
"_____no_output_____"
]
],
[
[
"blist[::2]",
"_____no_output_____"
],
[
"print(blist[::-1]) # An easy way to reverse the order of elements\nprint(blist)",
"[7, 6, 5, 3.0, 'two', 1, '0', 7, 6, 5, 3.0, 'two', 1, '0']\n['0', 1, 'two', 3.0, 5, 6, 7, '0', 1, 'two', 3.0, 5, 6, 7]\n"
]
],
[
[
"A simple built-in function that is used a lot is the range function. It is not a list but returns one so we will discuss it here briefly. The syntax of the function is range(starting number, ending number, step size ). All three function arguments are required to be integers with the ending number not being included in the list. Additionally the step size does not have to be specified, and if it is not the value is assumed to be 1.",
"_____no_output_____"
]
],
[
[
"for i in range(0,10):\n print(i)",
"0\n1\n2\n3\n4\n5\n6\n7\n8\n9\n"
],
[
"for batman in range(0,10,2):\n print(batman)",
"0\n2\n4\n6\n8\n"
]
],
[
[
"### Conditional Statements\n\nConditionals are useful for **altering the flow of control** in your programs. For example, you can execute blocks of code (or skip them entirely) if certain conditions are met.\n\nConditions are created using `if/elif/else` blocks.\n\nFor those of you familiar with C, C++, Java, and similar languages, you are probably used to code blocks being marked off with curly braces: { }\n\nIn Python braces are not used. Code blocks are *indented*, and the Python interpreter decides what's in a block depending on the indentation. Good practice (for readability) is to use 4 spaces per indentation. If you are programming in a jupyter notebook, the notebook will automatically indent conditional blocks for you.",
"_____no_output_____"
]
],
[
[
"x = 54\n\nif x > 10:\n print(\"x > 10\")\nelif x > 5:\n print(\"x > 5\")\nelse:\n print(\"x <= 5\")",
"x > 10\n"
],
[
"isEven = (x % 2 == 0) # Store a boolean value\nprint(isEven)\n\n# Note the perverse double negative in this boolean expression...\nif not isEven:\n print(\"x is odd\")\nelse:\n print(\"x is even\")",
"True\nx is even\n"
]
],
[
[
"#### Comparison Operators\n\nThere are several predefined operators used to make boolean comparisons in Python. They are similar to operators used in C, C++, and Java:\n\n`==` ... test for equality\n\n`!=` ... test for not equal\n\n`>` ... greater than\n\n`>=` ... greater than or equal to\n\n`<` ... less than\n\n`<=` ... less than or equal to\n\n#### Combining Boolean Values\n\nFollowing the usual rules of boolean algebra, boolean values can be negated or combined in several ways:\n\n##### Logical AND\n\nYou can combine two boolean variables using the operator `&&` or the keyword `and`:",
"_____no_output_____"
]
],
[
[
"print('x y | x && y')\nprint('---------------')\n\nfor x in [True, False]:\n for y in [True, False]:\n print('{:d} {:d} | {:d}'.format(x, y, x and y))",
"x y | x && y\n---------------\n1 1 | 1\n1 0 | 0\n0 1 | 0\n0 0 | 0\n"
],
[
"# Will evaluate to True and print the output.\n\nx = 10\nif x > 2 and x < 20:\n print(x)",
"10\n"
],
[
"# Will evaluate to False and not print the output.\n\nif x < 2 and x > 20:\n print(x)",
"_____no_output_____"
]
],
[
[
"##### Logical OR\n\nYou can also combine two boolean variables using the operator `||` or the keyword `or`:",
"_____no_output_____"
]
],
[
[
"print('x y | x || y')\nprint('---------------')\n\nfor x in [True, False]:\n for y in [True, False]:\n\n print('{:d} {:d} | {:d}'.format(x, y, x or y))",
"x y | x || y\n---------------\n1 1 | 1\n1 0 | 1\n0 1 | 1\n0 0 | 0\n"
],
[
"# Will evaluate to True and print the output.\n\nx = 10\nif x > 2 or x < 0:\n print(x)",
"10\n"
],
[
"# Will evaluate to False and print the output.\n\nif x < 2 or x > 20:\n print(x)",
"_____no_output_____"
]
],
[
[
"##### Logical NOT\n\nIt's possible to negate a boolean expression using the keyword `not`:",
"_____no_output_____"
]
],
[
[
"print('x | not x')\nprint('----------')\nfor x in [True, False]:\n print('{:d} | {:d}'.format(x, not x))",
"x | not x\n----------\n1 | 0\n0 | 1\n"
]
],
[
[
"A more complex truth table demonstrating the duality\n\n$\\overline{AB} = \\overline{A}+\\overline{B}$:",
"_____no_output_____"
]
],
[
[
"print('A B | A and B | !(A and B) | !A or !B')\nprint('-------------------------------------------')\nfor A in [True, False]:\n for B in [True, False]:\n print('{:d} {:d} | {:d} | {:d} | {:d}'.format(\n A, B, A and B, not (A and B), not A or not B)) ",
"A B | A and B | !(A and B) | !A or !B\n-------------------------------------------\n1 1 | 1 | 0 | 0\n1 0 | 0 | 1 | 1\n0 1 | 0 | 1 | 1\n0 0 | 0 | 1 | 1\n"
]
],
[
[
"### Loops\n\nLoops are useful for executing blocks of code as long as a logical condition is satisfied.\n\nOnce the loop condition is no longer satisfied, the flow of control is returned to the main body of the program. Note that **infinite loops**, a serious runtime bug where the loop condition never evaluates to `False`, are possible, so you have to be careful.\n\n#### While Loop\n\nThe `while` loop evaluates until a condition is false. Note that loops can be nested inside each other, and can also contain nested conditional statements.",
"_____no_output_____"
]
],
[
[
"i = 0\nwhile i < 10: # Loop condition: i < 10\n i += 1 # Increment the value of i\n if i % 2 == 0: # Print i if it's even\n print(i)",
"2\n4\n6\n8\n10\n"
]
],
[
[
"#### For Loop\n\nThe `for` loop provides the same basic functionality as the `while` loop, but allows for a simpler syntax in certain cases.\n\nFor example, if we wanted to access all the elements inside a list one by one, we could write a while loop with a variable index `i` and access the list elements as `listname[i]`, incrementing `i` until it's the same size as the length of the list.\n\nHowever, the `for` loop lets us avoid the need to declare an index variable. For example:",
"_____no_output_____"
]
],
[
[
"for x in range(1,11): # Loop through a list of values [1..10]\n if x % 2 == 0: # Print the list value if it's even\n print(x)",
"2\n4\n6\n8\n10\n"
],
[
"for i, x in enumerate(['a', 'b', 'c', 'd', 'e']):\n print('{:d} {:s}'.format(i+1, x))",
"1 a\n2 b\n3 c\n4 d\n5 e\n"
]
],
[
[
"##### List Comprehension and Zipping Lists in a For Loop",
"_____no_output_____"
],
[
"If we are interested in building lists we can start from a blank list and append things to it in a for loop, or use a **list comprehension** which combines for loops and list creation into line. The syntax is a set of square brackets that contains formula and a for loop.",
"_____no_output_____"
]
],
[
[
"squaredrange = [e**2 for e in range(1,11)]\n\nprint(squaredrange)",
"[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n"
]
],
[
[
"You can also loop through **two lists simultaneously** using the `zip` function:",
"_____no_output_____"
]
],
[
[
"mylist = range(1,11)\nmylist2 = [e**2 for e in mylist]\n\nfor x, y in zip(mylist, mylist2):\n print('{:2d} {:4d}'.format(x, y))",
" 1 1\n 2 4\n 3 9\n 4 16\n 5 25\n 6 36\n 7 49\n 8 64\n 9 81\n10 100\n"
]
],
[
[
"### Functions\n\nFunctions are subroutines that accept some input and produce zero or more outputs. They are typically used to define common tasks in a program.\n\nRule of thumb: if you find that you are copying a piece of code over and over inside your script, it should probably go into a function.\n\n#### Example: Rounding\n\nThe following function will round integers to the nearest 10:",
"_____no_output_____"
]
],
[
[
"def round_int(x):\n # Note that we are using floor division (assumes Python 3).\n return 10 * ((x + 5)//10)\n\nfor x in range(2, 50, 5):\n print('{:5d} {:5d}'.format(x, round_int(x)))",
" 2 0\n 7 10\n 12 10\n 17 20\n 22 20\n 27 30\n 32 30\n 37 40\n 42 40\n 47 50\n"
]
],
[
[
"# In-Class Exercise\n\nWith the small amount we've gone through, you can already write reasonably sophisticated programs. For example, we can write a loop that generates the Fibonacci sequence.\n\nJust to remind you, the Fibonacci sequence is the list of numbers\n\n1, 1, 2, 3, 5, 8, 13, 21, 34, 55, ...\n\nIt is defined by the linear homogeneous recurrence relation\n\n$F_{n} = F_{n-1} + F_{n-2}$, where $F_0=F_1=1$.\n\nThe exercise is:\n1. Write a Python function that generate $F_n$ given $n$.\n2. Use your function to generate the first 100 numbers in the Fibonacci sequence.",
"_____no_output_____"
]
],
[
[
"# Easy implementation: recursive function\n\ndef fib(n):\n \"\"\"Generate term n of the Fibonacci sequence\"\"\"\n if n <= 1:\n # if n==0 or n==1: return 1\n return 1\n else:\n return fib(n-1) + fib(n-2)",
"_____no_output_____"
],
[
"# Only generate up to element 35 in the sequence, because this function is s-l-o-w.\n\nfor n in range(0, 35):\n Fn = fib(n)\n print('{:3d}{:25d}'.format(n, Fn))",
" 0 1\n 1 1\n 2 2\n 3 3\n 4 5\n 5 8\n 6 13\n 7 21\n 8 34\n 9 55\n 10 89\n 11 144\n 12 233\n 13 377\n 14 610\n 15 987\n 16 1597\n 17 2584\n 18 4181\n 19 6765\n 20 10946\n 21 17711\n 22 28657\n 23 46368\n 24 75025\n 25 121393\n 26 196418\n 27 317811\n 28 514229\n 29 832040\n 30 1346269\n 31 2178309\n 32 3524578\n 33 5702887\n 34 9227465\n"
]
],
[
[
"This function will work just fine for small n. Unfortunately, the recursive calls to `fib` cause the **function call stack** to grow rapidly with n. When n gets sufficiently large, you may hit the Python call stack limit. At that point your program will crash.\n\nEven worse, the call is s-l-o-w. Using the builtin `timeit` function available in the notebook, we can time the length of the function call to evaluate Fibonacci element 20. It will take several milliseconds, which doesn't sound bad, but it's actually very slow in computer terms. Imagine calling this function millions of times in a loop; it will be a huge bottleneck.",
"_____no_output_____"
]
],
[
[
"timeit(fib(20))",
"2 ms ± 39.6 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
]
],
[
[
"This next implementation uses two \"state variables\" `a` and `b` to build up the Fibonacci sequence. Instead of computing the series recursively, which builds up a huge stack of function calls in memory, all of the work is done by an internal `while` loop.",
"_____no_output_____"
]
],
[
[
"# Better implementation which uses two state variables to compute the sequence.\n\ndef fibBetter(n):\n \"\"\"Generate the Fibonacci series at position n\"\"\"\n a, b = 0, 1 # initial values\n while n > 0: # build up the series from n=0\n a, b, n = b, a+b, n-1 # store results in loop variables\n return b",
"_____no_output_____"
]
],
[
[
"While this doesn't seem like a major change, the time it takes to run the function is of order a few microseconds, or 1000 times faster than the recursive version. Quite a nice optimization!",
"_____no_output_____"
]
],
[
[
"timeit(fibBetter(20))",
"1.31 µs ± 16.9 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
]
],
[
[
"As a result, it's trivial to compute the first 100 Fibonacci numbers; `fibBetter` runs almost instantly, while `fib` probably would have crashed the notebook due to its memory requirements before getting even halfway through.",
"_____no_output_____"
]
],
[
[
"for n in range(0, 100):\n Fn = fibBetter(n)\n print(\"%3d%25d\" % (n, Fn))",
" 0 1\n 1 1\n 2 2\n 3 3\n 4 5\n 5 8\n 6 13\n 7 21\n 8 34\n 9 55\n 10 89\n 11 144\n 12 233\n 13 377\n 14 610\n 15 987\n 16 1597\n 17 2584\n 18 4181\n 19 6765\n 20 10946\n 21 17711\n 22 28657\n 23 46368\n 24 75025\n 25 121393\n 26 196418\n 27 317811\n 28 514229\n 29 832040\n 30 1346269\n 31 2178309\n 32 3524578\n 33 5702887\n 34 9227465\n 35 14930352\n 36 24157817\n 37 39088169\n 38 63245986\n 39 102334155\n 40 165580141\n 41 267914296\n 42 433494437\n 43 701408733\n 44 1134903170\n 45 1836311903\n 46 2971215073\n 47 4807526976\n 48 7778742049\n 49 12586269025\n 50 20365011074\n 51 32951280099\n 52 53316291173\n 53 86267571272\n 54 139583862445\n 55 225851433717\n 56 365435296162\n 57 591286729879\n 58 956722026041\n 59 1548008755920\n 60 2504730781961\n 61 4052739537881\n 62 6557470319842\n 63 10610209857723\n 64 17167680177565\n 65 27777890035288\n 66 44945570212853\n 67 72723460248141\n 68 117669030460994\n 69 190392490709135\n 70 308061521170129\n 71 498454011879264\n 72 806515533049393\n 73 1304969544928657\n 74 2111485077978050\n 75 3416454622906707\n 76 5527939700884757\n 77 8944394323791464\n 78 14472334024676221\n 79 23416728348467685\n 80 37889062373143906\n 81 61305790721611591\n 82 99194853094755497\n 83 160500643816367088\n 84 259695496911122585\n 85 420196140727489673\n 86 679891637638612258\n 87 1100087778366101931\n 88 1779979416004714189\n 89 2880067194370816120\n 90 4660046610375530309\n 91 7540113804746346429\n 92 12200160415121876738\n 93 19740274219868223167\n 94 31940434634990099905\n 95 51680708854858323072\n 96 83621143489848422977\n 97 135301852344706746049\n 98 218922995834555169026\n 99 354224848179261915075\n"
]
],
[
[
"## Accessing Functions Beyond the Built-In Functions\n\nIf we want to use libraries and modules not defined within the built-in functionality of python we have to import them. There are a number of ways to do this.",
"_____no_output_____"
]
],
[
[
"import numpy as np\nimport scipy as sp",
"_____no_output_____"
]
],
[
[
"This imports the module `numpy` and the module `scipy`, and creates a reference to that modules in the current namespace. After you’ve run this statement, you can use `np.name` and `sp.name` to refer to constants, functions, and classes defined in module numpy and scipy.",
"_____no_output_____"
]
],
[
[
"np.pi",
"_____no_output_____"
],
[
"# Evaluate the sine and cosine of 120 degrees.\nnp.sin(2*np.pi/3), np.cos(2*np.pi/3)",
"_____no_output_____"
],
[
"# Exponentiation and logarithms.\n\na = np.exp(-1.) # 1/e = 0.368\nb = np.log(a) # ln(1/e) = -1\nc = np.log2(a) # base-2 log of 1/e\nd = np.log10(a) # base-10 log of 1/e\n\na, b, c, d",
"_____no_output_____"
],
[
"from numpy import *",
"_____no_output_____"
]
],
[
[
"This imports the module numpy, and creates references in the current namespace to all public objects defined by that module (that is, everything that doesn’t have a name starting with “_”).\n\nOr in other words, after you’ve run this statement, you can simply use a plain name to refer to things defined in module numpy. Here, numpy itself is not defined, so numpy.name doesn’t work. If name was already defined, it is replaced by the new version. Also, if name in numpy is changed to point to some other object, your module won’t notice.",
"_____no_output_____"
]
],
[
[
"pi",
"_____no_output_____"
]
],
[
[
"#### Importing Submodules\n\nYou can also import submodules from within a module.\n\nFor example, `scipy` has a submodule called `special` that contains a number of useful transcendental functions beyond the basic exponentiation and trigonometric functions available in `numpy`.\n\nIn the example below, we make three function calls to the Error function `Erf` using this module.",
"_____no_output_____"
]
],
[
[
"from scipy import special\n\n# The error function is the cumulative distribution of a Gaussian with mean 0 and width 1\n# (a.k.a., the normal distribution).\n\nprint(special.erf(0),\n special.erf(1),\n special.erf(2))",
"0.0 0.8427007929497148 0.9953222650189527\n"
]
],
[
[
"## NumPy Tips and Tricks\n\nNumPy is optimized for numerical work. The `array` type inside of the module behaves a lot like a list, but it is *vectorized* so that you can apply arithmetic operations and other functions to the array without having to loop through it.\n\nFor example, when we wanted to square every element inside a python list we used a list comprehension:",
"_____no_output_____"
]
],
[
[
"mylist = range(1,11)\n[x**2 for x in mylist]",
"_____no_output_____"
]
],
[
[
"This isn't that hard, but the syntax is a little ugly and we do have to explicitly loop through the list. In contrast, to square all the elements in the NumPy array you just apply the operator to the array variable itself:",
"_____no_output_____"
]
],
[
[
"myarray = np.arange(1,11)\nmyarray**2",
"_____no_output_____"
]
],
[
[
"### Evenly Spaced Numbers\n\nNumPy provides two functions to give evenly spaced numbers on linear or logarithmic scales.",
"_____no_output_____"
]
],
[
[
"np.linspace(1, 10, 21) # gives 21 evenly spaced numbers in [1..10]",
"_____no_output_____"
],
[
"np.logspace(1, 6, 6) # gives 6 logarithmically spaced numbers\n # between 1e1=10 and 1e6=1000000",
"_____no_output_____"
],
[
"np.logspace(1, 6, 6, base=2) # same as above, but using base-2 logarithm",
"_____no_output_____"
]
],
[
[
"### Slicing Arrays with Boolean Masks\n\nAn extremely useful feature in NumPy is the ability to create a \"mask\" array which can select values satisfying a logical condition:",
"_____no_output_____"
]
],
[
[
"x = np.arange(0, 8) # [0, 1, 2, 3, 4, 5, 6, 7]\ny = 3*x # [0, 3, 6, 9, 12, 15, 18, 21]\n\nc = x < 3\n\n# Print whether or not each element is < 3.\nprint(c)",
"[ True True True False False False False False]\n"
],
[
"# Select out only the elements of x for which the corresponding elements of c are < 3.\nprint(x[c])",
"[0 1 2]\n"
],
[
"# Select out only the elements of y for which the corresponding elements of c are < 3.\nprint(y[c])\n\n# Select out only the elements of y for which the corresponding elements of x are >= 3.\nprint(y[x >= 3])",
"[0 3 6]\n[ 9 12 15 18 21]\n"
],
[
"# Combine cuts on x with bitwise OR (| symbol) or AND (& symbol).\nc = (x<3) | (x>5)\nprint(y[c])",
"[ 0 3 6 18 21]\n"
]
],
[
[
"This is the type of selection used *all the time* in data analysis.",
"_____no_output_____"
],
[
"### File Input/Output\n\nStandard Python has functions to read basic text and binary files from disk.\n\nHowever, for numerical analysis your files will usually be nicely formatted into numerical columns separated by spaces, commas, etc. For reading such files, NumPy has a nice function called `genfromtxt`:",
"_____no_output_____"
]
],
[
[
"# Load data from file into a multidimensional array\ndata = np.genfromtxt('intro/data.txt')\n\nx = data[:,0] # x is the first column (numbering starts @ 0)\ny = data[:,1] # y is the second column\n\nprint(x)\nprint(y)",
"[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]\n[ 1. 4. 9. 16. 25. 36. 49. 64. 81. 100.]\n"
]
],
[
[
"## Plotting with Matplotlib\n\nMatplotlib is used to plot data and can be used to produce the usual xy scatter plots, contour plots, histograms, etc. that you're used to making for all basic data analyses.\n\nI strongly recommend that you go to the Matplotlib website and check out the huge <a href=\"http://matplotlib.org/gallery.html\">plot gallery</a>. This is the easiest way to learn how to make a particular kind of plot.",
"_____no_output_____"
]
],
[
[
"import matplotlib.pyplot as plt",
"_____no_output_____"
],
[
"plt.plot(x, y, \"k.\")\nplt.xlabel(\"x [arb. units]\")\nplt.ylabel(\"y [arb. units]\")\nplt.title(\"Some XY data\");",
"_____no_output_____"
]
],
[
[
"Here is an example of how to change the default formatting of the text in your plot. Also note how LaTeX is supported!",
"_____no_output_____"
]
],
[
[
"import matplotlib as mpl\nmpl.rc('font', size=16)\n\nplt.plot(x, y, \"k.\")\nplt.xlabel(r\"$\\sin({x)}$ [arb. units]\")\nplt.ylabel(r\"$\\zeta(y)$ [arb. units]\")\nplt.title(\"Some XY data\")",
"_____no_output_____"
]
],
[
[
"### Using NumPy and Matplotlib Together\n\nHere we create some fake data with NumPy and plot it, including a legend.",
"_____no_output_____"
]
],
[
[
"x = np.linspace(-np.pi, np.pi, 1000, endpoint=True)\nc = np.cos(x)\ns = np.sin(x)\n\nplt.plot(x,c,label=\"Cosine\",color=\"r\",linestyle=\"--\",linewidth=2)\nplt.plot(x,s,label=\"Sine\",color=\"b\",linestyle=\"-.\",linewidth=2)\nplt.xlabel(\"$x$\",fontsize=14)\nplt.xlim(-np.pi,np.pi)\n\n# Override default ticks and labels\nxticks = [-np.pi, -0.5*np.pi, 0, 0.5*np.pi, np.pi]\nlabels = [\"$-\\pi$\", \"$-\\pi/2$\", \"$0$\", \"$\\pi/2$\", \"$\\pi$\"]\nplt.xticks(xticks, labels)\n\nplt.ylabel(\"$y$\",fontsize=14)\nplt.ylim(-1,1)\nplt.legend(fontsize=14, loc=\"best\", numpoints=1)",
"_____no_output_____"
]
],
[
[
"## Help Manual and Inspection\n\nWhen running interactive sessions, you can use the built-in help function to view module and function documentation.\n\nFor example, here is how to view the internal documentation for the built-in function that calculates the greatest common divisor of two numbers:",
"_____no_output_____"
]
],
[
[
"from fractions import gcd\n\nhelp(gcd)",
"Help on function gcd in module fractions:\n\ngcd(a, b)\n Calculate the Greatest Common Divisor of a and b.\n \n Unless b==0, the result will have the same sign as b (so that when\n b is divided by it, the result comes out positive).\n\n"
]
],
[
[
"The `inspect` module is nice if you actually want to look at the **source code** of a function. Just import inspect and call the `getsource` function for the code you want to see:",
"_____no_output_____"
]
],
[
[
"from inspect import getsource\n\nprint(getsource(gcd))",
"def gcd(a, b):\n \"\"\"Calculate the Greatest Common Divisor of a and b.\n\n Unless b==0, the result will have the same sign as b (so that when\n b is divided by it, the result comes out positive).\n \"\"\"\n import warnings\n warnings.warn('fractions.gcd() is deprecated. Use math.gcd() instead.',\n DeprecationWarning, 2)\n if type(a) is int is type(b):\n if (b or a) < 0:\n return -math.gcd(a, b)\n return math.gcd(a, b)\n return _gcd(a, b)\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",
"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",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
ece9f0bbbb70a081c59b7f450b7ace2879f6aeec | 35,253 | ipynb | Jupyter Notebook | original_code/ch04.ipynb | jieunjeon/CatchingDudeoji | 6cbb7b8d484ff21eac2d2640a862decfb5e3b9be | [
"MIT"
] | 6 | 2021-07-16T11:16:00.000Z | 2021-08-31T09:23:27.000Z | original_code/ch04.ipynb | jieunjeon/CatchingDudeoji | 6cbb7b8d484ff21eac2d2640a862decfb5e3b9be | [
"MIT"
] | 3 | 2021-07-27T03:14:17.000Z | 2021-08-02T10:44:42.000Z | original_code/ch04.ipynb | jieunjeon/CatchingDudeoji | 6cbb7b8d484ff21eac2d2640a862decfb5e3b9be | [
"MIT"
] | 22 | 2021-07-18T01:25:01.000Z | 2021-08-20T10:28:31.000Z | 18.983845 | 82 | 0.460812 | [
[
[
"# NumPy Basics: Arrays and Vectorized Computation",
"_____no_output_____"
]
],
[
[
"import numpy as np\nnp.random.seed(12345)\nimport matplotlib.pyplot as plt\nplt.rc('figure', figsize=(10, 6))\nnp.set_printoptions(precision=4, suppress=True)",
"_____no_output_____"
],
[
"import numpy as np\nmy_arr = np.arange(1000000)\nmy_list = list(range(1000000))",
"_____no_output_____"
],
[
"%time for _ in range(10): my_arr2 = my_arr * 2\n%time for _ in range(10): my_list2 = [x * 2 for x in my_list]",
"_____no_output_____"
]
],
[
[
"## The NumPy ndarray: A Multidimensional Array Object",
"_____no_output_____"
]
],
[
[
"import numpy as np\n# Generate some random data\ndata = np.random.randn(2, 3)\ndata",
"_____no_output_____"
],
[
"data * 10\ndata + data",
"_____no_output_____"
],
[
"data.shape\ndata.dtype",
"_____no_output_____"
]
],
[
[
"### Creating ndarrays",
"_____no_output_____"
]
],
[
[
"data1 = [6, 7.5, 8, 0, 1]\narr1 = np.array(data1)\narr1",
"_____no_output_____"
],
[
"data2 = [[1, 2, 3, 4], [5, 6, 7, 8]]\narr2 = np.array(data2)\narr2",
"_____no_output_____"
],
[
"arr2.ndim\narr2.shape",
"_____no_output_____"
],
[
"arr1.dtype\narr2.dtype",
"_____no_output_____"
],
[
"np.zeros(10)\nnp.zeros((3, 6))\nnp.empty((2, 3, 2))",
"_____no_output_____"
],
[
"np.arange(15)",
"_____no_output_____"
]
],
[
[
"### Data Types for ndarrays",
"_____no_output_____"
]
],
[
[
"arr1 = np.array([1, 2, 3], dtype=np.float64)\narr2 = np.array([1, 2, 3], dtype=np.int32)\narr1.dtype\narr2.dtype",
"_____no_output_____"
],
[
"arr = np.array([1, 2, 3, 4, 5])\narr.dtype\nfloat_arr = arr.astype(np.float64)\nfloat_arr.dtype",
"_____no_output_____"
],
[
"arr = np.array([3.7, -1.2, -2.6, 0.5, 12.9, 10.1])\narr\narr.astype(np.int32)",
"_____no_output_____"
],
[
"numeric_strings = np.array(['1.25', '-9.6', '42'], dtype=np.string_)\nnumeric_strings.astype(float)",
"_____no_output_____"
],
[
"int_array = np.arange(10)\ncalibers = np.array([.22, .270, .357, .380, .44, .50], dtype=np.float64)\nint_array.astype(calibers.dtype)",
"_____no_output_____"
],
[
"empty_uint32 = np.empty(8, dtype='u4')\nempty_uint32",
"_____no_output_____"
]
],
[
[
"### Arithmetic with NumPy Arrays",
"_____no_output_____"
]
],
[
[
"arr = np.array([[1., 2., 3.], [4., 5., 6.]])\narr\narr * arr\narr - arr",
"_____no_output_____"
],
[
"1 / arr\narr ** 0.5",
"_____no_output_____"
],
[
"arr2 = np.array([[0., 4., 1.], [7., 2., 12.]])\narr2\narr2 > arr",
"_____no_output_____"
]
],
[
[
"### Basic Indexing and Slicing",
"_____no_output_____"
]
],
[
[
"arr = np.arange(10)\narr\narr[5]\narr[5:8]\narr[5:8] = 12\narr",
"_____no_output_____"
],
[
"arr_slice = arr[5:8]\narr_slice",
"_____no_output_____"
],
[
"arr_slice[1] = 12345\narr",
"_____no_output_____"
],
[
"arr_slice[:] = 64\narr",
"_____no_output_____"
],
[
"arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])\narr2d[2]",
"_____no_output_____"
],
[
"arr2d[0][2]\narr2d[0, 2]",
"_____no_output_____"
],
[
"arr3d = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])\narr3d",
"_____no_output_____"
],
[
"arr3d[0]",
"_____no_output_____"
],
[
"old_values = arr3d[0].copy()\narr3d[0] = 42\narr3d\narr3d[0] = old_values\narr3d",
"_____no_output_____"
],
[
"arr3d[1, 0]",
"_____no_output_____"
],
[
"x = arr3d[1]\nx\nx[0]",
"_____no_output_____"
]
],
[
[
"#### Indexing with slices",
"_____no_output_____"
]
],
[
[
"arr\narr[1:6]",
"_____no_output_____"
],
[
"arr2d\narr2d[:2]",
"_____no_output_____"
],
[
"arr2d[:2, 1:]",
"_____no_output_____"
],
[
"arr2d[1, :2]",
"_____no_output_____"
],
[
"arr2d[:2, 2]",
"_____no_output_____"
],
[
"arr2d[:, :1]",
"_____no_output_____"
],
[
"arr2d[:2, 1:] = 0\narr2d",
"_____no_output_____"
]
],
[
[
"### Boolean Indexing",
"_____no_output_____"
]
],
[
[
"names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\ndata = np.random.randn(7, 4)\nnames\ndata",
"_____no_output_____"
],
[
"names == 'Bob'",
"_____no_output_____"
],
[
"data[names == 'Bob']",
"_____no_output_____"
],
[
"data[names == 'Bob', 2:]\ndata[names == 'Bob', 3]",
"_____no_output_____"
],
[
"names != 'Bob'\ndata[~(names == 'Bob')]",
"_____no_output_____"
],
[
"cond = names == 'Bob'\ndata[~cond]",
"_____no_output_____"
],
[
"mask = (names == 'Bob') | (names == 'Will')\nmask\ndata[mask]",
"_____no_output_____"
],
[
"data[data < 0] = 0\ndata",
"_____no_output_____"
],
[
"data[names != 'Joe'] = 7\ndata",
"_____no_output_____"
]
],
[
[
"### Fancy Indexing",
"_____no_output_____"
]
],
[
[
"arr = np.empty((8, 4))\nfor i in range(8):\n arr[i] = i\narr",
"_____no_output_____"
],
[
"arr[[4, 3, 0, 6]]",
"_____no_output_____"
],
[
"arr[[-3, -5, -7]]",
"_____no_output_____"
],
[
"arr = np.arange(32).reshape((8, 4))\narr\narr[[1, 5, 7, 2], [0, 3, 1, 2]]",
"_____no_output_____"
],
[
"arr[[1, 5, 7, 2]][:, [0, 3, 1, 2]]",
"_____no_output_____"
]
],
[
[
"### Transposing Arrays and Swapping Axes",
"_____no_output_____"
]
],
[
[
"arr = np.arange(15).reshape((3, 5))\narr\narr.T",
"_____no_output_____"
],
[
"arr = np.random.randn(6, 3)\narr\nnp.dot(arr.T, arr)",
"_____no_output_____"
],
[
"arr = np.arange(16).reshape((2, 2, 4))\narr\narr.transpose((1, 0, 2))",
"_____no_output_____"
],
[
"arr\narr.swapaxes(1, 2)",
"_____no_output_____"
]
],
[
[
"## Universal Functions: Fast Element-Wise Array Functions",
"_____no_output_____"
]
],
[
[
"arr = np.arange(10)\narr\nnp.sqrt(arr)\nnp.exp(arr)",
"_____no_output_____"
],
[
"x = np.random.randn(8)\ny = np.random.randn(8)\nx\ny\nnp.maximum(x, y)",
"_____no_output_____"
],
[
"arr = np.random.randn(7) * 5\narr\nremainder, whole_part = np.modf(arr)\nremainder\nwhole_part",
"_____no_output_____"
],
[
"arr\nnp.sqrt(arr)\nnp.sqrt(arr, arr)\narr",
"_____no_output_____"
]
],
[
[
"## Array-Oriented Programming with Arrays",
"_____no_output_____"
]
],
[
[
"points = np.arange(-5, 5, 0.01) # 1000 equally spaced points\nxs, ys = np.meshgrid(points, points)\nys",
"_____no_output_____"
],
[
"z = np.sqrt(xs ** 2 + ys ** 2)\nz",
"_____no_output_____"
],
[
"import matplotlib.pyplot as plt\nplt.imshow(z, cmap=plt.cm.gray); plt.colorbar()\nplt.title(\"Image plot of $\\sqrt{x^2 + y^2}$ for a grid of values\")",
"_____no_output_____"
],
[
"plt.draw()",
"_____no_output_____"
],
[
"plt.close('all')",
"_____no_output_____"
]
],
[
[
"### Expressing Conditional Logic as Array Operations",
"_____no_output_____"
]
],
[
[
"xarr = np.array([1.1, 1.2, 1.3, 1.4, 1.5])\nyarr = np.array([2.1, 2.2, 2.3, 2.4, 2.5])\ncond = np.array([True, False, True, True, False])",
"_____no_output_____"
],
[
"result = [(x if c else y)\n for x, y, c in zip(xarr, yarr, cond)]\nresult",
"_____no_output_____"
],
[
"result = np.where(cond, xarr, yarr)\nresult",
"_____no_output_____"
],
[
"arr = np.random.randn(4, 4)\narr\narr > 0\nnp.where(arr > 0, 2, -2)",
"_____no_output_____"
],
[
"np.where(arr > 0, 2, arr) # set only positive values to 2",
"_____no_output_____"
]
],
[
[
"### Mathematical and Statistical Methods",
"_____no_output_____"
]
],
[
[
"arr = np.random.randn(5, 4)\narr\narr.mean()\nnp.mean(arr)\narr.sum()",
"_____no_output_____"
],
[
"arr.mean(axis=1)\narr.sum(axis=0)",
"_____no_output_____"
],
[
"arr = np.array([0, 1, 2, 3, 4, 5, 6, 7])\narr.cumsum()",
"_____no_output_____"
],
[
"arr = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8]])\narr\narr.cumsum(axis=0)\narr.cumprod(axis=1)",
"_____no_output_____"
]
],
[
[
"### Methods for Boolean Arrays",
"_____no_output_____"
]
],
[
[
"arr = np.random.randn(100)\n(arr > 0).sum() # Number of positive values",
"_____no_output_____"
],
[
"bools = np.array([False, False, True, False])\nbools.any()\nbools.all()",
"_____no_output_____"
]
],
[
[
"### Sorting",
"_____no_output_____"
]
],
[
[
"arr = np.random.randn(6)\narr\narr.sort()\narr",
"_____no_output_____"
],
[
"arr = np.random.randn(5, 3)\narr\narr.sort(1)\narr",
"_____no_output_____"
],
[
"large_arr = np.random.randn(1000)\nlarge_arr.sort()\nlarge_arr[int(0.05 * len(large_arr))] # 5% quantile",
"_____no_output_____"
]
],
[
[
"### Unique and Other Set Logic",
"_____no_output_____"
]
],
[
[
"names = np.array(['Bob', 'Joe', 'Will', 'Bob', 'Will', 'Joe', 'Joe'])\nnp.unique(names)\nints = np.array([3, 3, 3, 2, 2, 1, 1, 4, 4])\nnp.unique(ints)",
"_____no_output_____"
],
[
"sorted(set(names))",
"_____no_output_____"
],
[
"values = np.array([6, 0, 0, 3, 2, 5, 6])\nnp.in1d(values, [2, 3, 6])",
"_____no_output_____"
]
],
[
[
"## File Input and Output with Arrays",
"_____no_output_____"
]
],
[
[
"arr = np.arange(10)\nnp.save('some_array', arr)",
"_____no_output_____"
],
[
"np.load('some_array.npy')",
"_____no_output_____"
],
[
"np.savez('array_archive.npz', a=arr, b=arr)",
"_____no_output_____"
],
[
"arch = np.load('array_archive.npz')\narch['b']",
"_____no_output_____"
],
[
"np.savez_compressed('arrays_compressed.npz', a=arr, b=arr)",
"_____no_output_____"
],
[
"!rm some_array.npy\n!rm array_archive.npz\n!rm arrays_compressed.npz",
"_____no_output_____"
]
],
[
[
"## Linear Algebra",
"_____no_output_____"
]
],
[
[
"x = np.array([[1., 2., 3.], [4., 5., 6.]])\ny = np.array([[6., 23.], [-1, 7], [8, 9]])\nx\ny\nx.dot(y)",
"_____no_output_____"
],
[
"np.dot(x, y)",
"_____no_output_____"
],
[
"np.dot(x, np.ones(3))",
"_____no_output_____"
],
[
"x @ np.ones(3)",
"_____no_output_____"
],
[
"from numpy.linalg import inv, qr\nX = np.random.randn(5, 5)\nmat = X.T.dot(X)\ninv(mat)\nmat.dot(inv(mat))\nq, r = qr(mat)\nr",
"_____no_output_____"
]
],
[
[
"## Pseudorandom Number Generation",
"_____no_output_____"
]
],
[
[
"samples = np.random.normal(size=(4, 4))\nsamples",
"_____no_output_____"
],
[
"from random import normalvariate\nN = 1000000\n%timeit samples = [normalvariate(0, 1) for _ in range(N)]\n%timeit np.random.normal(size=N)",
"_____no_output_____"
],
[
"np.random.seed(1234)",
"_____no_output_____"
],
[
"rng = np.random.RandomState(1234)\nrng.randn(10)",
"_____no_output_____"
]
],
[
[
"## Example: Random Walks",
"_____no_output_____"
]
],
[
[
"import random\nposition = 0\nwalk = [position]\nsteps = 1000\nfor i in range(steps):\n step = 1 if random.randint(0, 1) else -1\n position += step\n walk.append(position)",
"_____no_output_____"
],
[
"plt.figure()",
"_____no_output_____"
],
[
"plt.plot(walk[:100])",
"_____no_output_____"
],
[
"np.random.seed(12345)",
"_____no_output_____"
],
[
"nsteps = 1000\ndraws = np.random.randint(0, 2, size=nsteps)\nsteps = np.where(draws > 0, 1, -1)\nwalk = steps.cumsum()",
"_____no_output_____"
],
[
"walk.min()\nwalk.max()",
"_____no_output_____"
],
[
"(np.abs(walk) >= 10).argmax()",
"_____no_output_____"
]
],
[
[
"### Simulating Many Random Walks at Once",
"_____no_output_____"
]
],
[
[
"nwalks = 5000\nnsteps = 1000\ndraws = np.random.randint(0, 2, size=(nwalks, nsteps)) # 0 or 1\nsteps = np.where(draws > 0, 1, -1)\nwalks = steps.cumsum(1)\nwalks",
"_____no_output_____"
],
[
"walks.max()\nwalks.min()",
"_____no_output_____"
],
[
"hits30 = (np.abs(walks) >= 30).any(1)\nhits30\nhits30.sum() # Number that hit 30 or -30",
"_____no_output_____"
],
[
"crossing_times = (np.abs(walks[hits30]) >= 30).argmax(1)\ncrossing_times.mean()",
"_____no_output_____"
],
[
"steps = np.random.normal(loc=0, scale=0.25,\n size=(nwalks, nsteps))",
"_____no_output_____"
]
],
[
[
"## 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"
] | [
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
]
] |
ece9f5860a8a4a18be5490fc13c6f2dadcfcddc8 | 826 | ipynb | Jupyter Notebook | Function and Circulation/fiveTimes.ipynb | npukujui11/Automate_with_Pyhton | d1d810da53222b9642674d8dd2ed2dbe5afae326 | [
"MIT"
] | null | null | null | Function and Circulation/fiveTimes.ipynb | npukujui11/Automate_with_Pyhton | d1d810da53222b9642674d8dd2ed2dbe5afae326 | [
"MIT"
] | null | null | null | Function and Circulation/fiveTimes.ipynb | npukujui11/Automate_with_Pyhton | d1d810da53222b9642674d8dd2ed2dbe5afae326 | [
"MIT"
] | null | null | null | 20.65 | 137 | 0.529056 | [
[
[
"print('My name is')\nfor i in range(5):\n print('Jimmy Five Times (' + str(i) + ')')",
"My name is\nJimmy Five Times (0)\nJimmy Five Times (1)\nJimmy Five Times (2)\nJimmy Five Times (3)\nJimmy Five Times (4)\n"
]
]
] | [
"code"
] | [
[
"code"
]
] |
ece9fa1ffba09a43de54a26bc916a848802e0f95 | 12,417 | ipynb | Jupyter Notebook | Lecture7_RNN_intro.ipynb | CharlesPoletowin/YCBS-273 | 28678a5e693cad6d29ac3cc7a9f53acb551d4470 | [
"MIT"
] | null | null | null | Lecture7_RNN_intro.ipynb | CharlesPoletowin/YCBS-273 | 28678a5e693cad6d29ac3cc7a9f53acb551d4470 | [
"MIT"
] | null | null | null | Lecture7_RNN_intro.ipynb | CharlesPoletowin/YCBS-273 | 28678a5e693cad6d29ac3cc7a9f53acb551d4470 | [
"MIT"
] | 1 | 2020-07-28T14:25:16.000Z | 2020-07-28T14:25:16.000Z | 32.762533 | 242 | 0.472417 | [
[
[
"<a href=\"https://colab.research.google.com/github/CharlesPoletowin/YCBS-273/blob/master/Lecture7_RNN_intro.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>",
"_____no_output_____"
]
],
[
[
"import time\nfrom sklearn.metrics import accuracy_score",
"_____no_output_____"
]
],
[
[
"This notebook was inspired from https://github.com/bentrevett/pytorch-sentiment-analysis. Great thanks to the authors!",
"_____no_output_____"
],
[
"# Data setup",
"_____no_output_____"
]
],
[
[
"import torch\nfrom torch.utils.data import TensorDataset\nfrom torch.utils.data import DataLoader\n\ndef get_data(seq_len, inp_dim, device, data_size=25000):\n\n data = torch.randint(low=0, high=inp_dim, size=(data_size, seq_len), out=None, device=device)\n labels = torch.abs(data[:, 0])\n\n train_data = TensorDataset(data[:int(0.7*data_size)], labels[:int(0.7*data_size)])\n valid_data = TensorDataset(data[int(0.7*data_size): int(0.85*data_size)], labels[int(0.7*data_size): int(0.85*data_size)])\n test_data = TensorDataset(data[int(0.85*data_size): int(data_size)], labels[int(0.85*data_size): int(data_size)])\n\n train_data_loader = DataLoader(train_data, batch_size=64)\n valid_data_loader = DataLoader(valid_data, batch_size=64)\n test_data_loader = DataLoader(test_data, batch_size=64)\n \n return train_data_loader, valid_data_loader, test_data_loader",
"_____no_output_____"
]
],
[
[
"# Model definition",
"_____no_output_____"
]
],
[
[
"import torch.nn as nn\n\nclass RNN(nn.Module):\n def __init__(self, input_dim, embedding_dim, hidden_dim, output_dim):\n \n super().__init__()\n \n self.embedding = nn.Embedding(input_dim, embedding_dim)\n \n self.rnn = nn.RNN(embedding_dim, hidden_dim)\n \n self.fc = nn.Linear(hidden_dim, output_dim)\n \n def forward(self, text):\n\n #text = [seq len, batch size]\n \n embedded = self.embedding(text)\n \n #embedded = [seq len, batch size, emb dim]\n \n output, hidden = self.rnn(embedded)\n \n #output = [seq len, batch size, hid dim]\n #hidden = [1, batch size, hid dim]\n \n assert torch.equal(output[-1,:,:], hidden.squeeze(0))\n \n \n \n return self.fc(hidden.squeeze(0))",
"_____no_output_____"
],
[
"def count_parameters(model):\n return sum(p.numel() for p in model.parameters() if p.requires_grad)",
"_____no_output_____"
]
],
[
[
"# Loss function",
"_____no_output_____"
]
],
[
[
"import torch.nn.functional as F\n\nloss_func = F.cross_entropy",
"_____no_output_____"
]
],
[
[
"# Optimizer",
"_____no_output_____"
]
],
[
[
"import torch.optim as optim",
"_____no_output_____"
],
[
"def evaluate(model, data_iterator, loss_func):\n \n epoch_loss = 0\n epoch_acc = 0\n \n model.eval()\n \n with torch.no_grad():\n \n for inp, label in data_iterator:\n\n predictions = model(inp.t()).squeeze(1)\n \n loss = loss_func(predictions, label)\n \n acc = accuracy_score(torch.argmax(predictions, dim=1).cpu().detach().numpy(), label.cpu().numpy())\n\n epoch_loss += loss.item()\n epoch_acc += acc\n \n return epoch_acc / len(data_iterator), epoch_loss / len(data_iterator)",
"_____no_output_____"
]
],
[
[
"# Training",
"_____no_output_____"
]
],
[
[
"def train_model(model, train_data, valid_data, loss_func, optimizer, epochs=5):\n\n for epoch in range(epochs):\n \n model.train()\n epoch_loss = 0\n epoch_acc = 0\n \n tic = time.time()\n for inp, label in train_data:\n \n predictions = model(inp.t()).squeeze(1)\n loss = loss_func(predictions, label)\n loss.backward()\n optimizer.step()\n optimizer.zero_grad()\n\n epoch_loss += loss.item()\n \n toc = time.time()\n \n train_acc, _ = evaluate(model, train_data, loss_func)\n acc, _ = evaluate(model, valid_data, loss_func)\n toe = time.time()\n print(len(train_data))\n print('Loss at epoch %d : %f, train acc : %f, valid acc : %f | train time : %d sec, eval time : %d sec' % (epoch, epoch_loss / len(train_data), train_acc, acc, toc-tic, toe - toc))",
"_____no_output_____"
],
[
"SEQ_LEN = 10\nINPUT_DIM = 50\nOUTPUT_DIM = INPUT_DIM\n\nEMBEDDING_DIM = 32\nHIDDEN_DIM = 256\n\nN_LAYERS = 1\nBIDIRECTIONAL = False\nDROPOUT = 0\n\ndevice = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n\ntrain_data_loader, valid_data_loader, test_data_loader = get_data(SEQ_LEN, INPUT_DIM, device=device, data_size=100000)\nmodel = RNN(INPUT_DIM, EMBEDDING_DIM, HIDDEN_DIM, OUTPUT_DIM) #, N_LAYERS, BIDIRECTIONAL, DROPOUT)\nmodel = model.to(device)\n\noptimizer = optim.Adam(model.parameters(), weight_decay=0.00001)\n\nprint(f'The model has {count_parameters(model):,} trainable parameters')\n\ntrain_model(model, train_data_loader, valid_data_loader, loss_func, optimizer, epochs=15)",
"The model has 88,690 trainable parameters\n1094\nLoss at epoch 0 : 0.448821, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 1 : 0.001877, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 2 : 0.000670, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 3 : 0.000333, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 4 : 0.032066, train acc : 0.999986, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 5 : 0.003594, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 6 : 0.000300, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 7 : 0.000162, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 8 : 0.000113, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 9 : 0.000094, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 10 : 0.027022, train acc : 0.999871, valid acc : 0.999867 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 11 : 0.000511, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 12 : 0.000166, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 13 : 0.000109, train acc : 1.000000, valid acc : 1.000000 | train time : 4 sec, eval time : 2 sec\n1094\nLoss at epoch 14 : 0.000083, train acc : 1.000000, valid acc : 1.000000 | train time : 5 sec, eval time : 2 sec\n"
],
[
"",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
]
] |
ecea0281b9041148b3f78fe3d7e947d010b821f6 | 38,183 | ipynb | Jupyter Notebook | Pandas_CombiningDataFrames.ipynb | MIDAS-26/Python_NumPy | fd5ba281981b6c92883707e1469b053318c13d24 | [
"Apache-2.0"
] | null | null | null | Pandas_CombiningDataFrames.ipynb | MIDAS-26/Python_NumPy | fd5ba281981b6c92883707e1469b053318c13d24 | [
"Apache-2.0"
] | null | null | null | Pandas_CombiningDataFrames.ipynb | MIDAS-26/Python_NumPy | fd5ba281981b6c92883707e1469b053318c13d24 | [
"Apache-2.0"
] | null | null | null | 25.88678 | 223 | 0.295734 | [
[
[
"# Merging, Joining, and Concatenating\n\nThere are 3 main ways of combining DataFrames together: Merging, Joining and Concatenating. In this lecture we will discuss these 3 methods with examples.\n\n____",
"_____no_output_____"
],
[
"### Example DataFrames",
"_____no_output_____"
]
],
[
[
"import pandas as pd",
"_____no_output_____"
],
[
"df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2', 'A3'],\r\n 'B': ['B0', 'B1', 'B2', 'B3'],\r\n 'C': ['C0', 'C1', 'C2', 'C3'],\r\n 'D': ['D0', 'D1', 'D2', 'D3']},\r\n index=[0, 1, 2, 3])",
"_____no_output_____"
],
[
"df2 = pd.DataFrame({'A': ['A4', 'A5', 'A6', 'A7'],\r\n 'B': ['B4', 'B5', 'B6', 'B7'],\r\n 'C': ['C4', 'C5', 'C6', 'C7'],\r\n 'D': ['D4', 'D5', 'D6', 'D7']},\r\n index=[4, 5, 6, 7]) ",
"_____no_output_____"
],
[
"df3 = pd.DataFrame({'A': ['A8', 'A9', 'A10', 'A11'],\r\n 'B': ['B8', 'B9', 'B10', 'B11'],\r\n 'C': ['C8', 'C9', 'C10', 'C11'],\r\n 'D': ['D8', 'D9', 'D10', 'D11']},\r\n index=[8, 9, 10, 11])",
"_____no_output_____"
],
[
"df1",
"_____no_output_____"
],
[
"df2",
"_____no_output_____"
],
[
"df3",
"_____no_output_____"
]
],
[
[
"## Concatenation\n\nConcatenation basically glues together DataFrames. Keep in mind that dimensions should match along the axis you are concatenating on. You can use **pd.concat** and pass in a list of DataFrames to concatenate together:",
"_____no_output_____"
]
],
[
[
"pd.concat([df1,df2,df3])",
"_____no_output_____"
],
[
"pd.concat([df1,df2,df3],axis=1)",
"_____no_output_____"
]
],
[
[
"_____\n## Example DataFrames",
"_____no_output_____"
]
],
[
[
"left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],\r\n 'A': ['A0', 'A1', 'A2', 'A3'],\r\n 'B': ['B0', 'B1', 'B2', 'B3']})\r\n \r\nright = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],\r\n 'C': ['C0', 'C1', 'C2', 'C3'],\r\n 'D': ['D0', 'D1', 'D2', 'D3']}) ",
"_____no_output_____"
],
[
"left",
"_____no_output_____"
],
[
"right",
"_____no_output_____"
]
],
[
[
"___",
"_____no_output_____"
],
[
"## Merging\n\nThe **merge** function allows you to merge DataFrames together using a similar logic as merging SQL Tables together. For example:",
"_____no_output_____"
]
],
[
[
"pd.merge(left,right,how='inner',on='key')",
"_____no_output_____"
]
],
[
[
"Or to show a more complicated example:",
"_____no_output_____"
]
],
[
[
"left = pd.DataFrame({'key1': ['K0', 'K0', 'K1', 'K2'],\r\n 'key2': ['K0', 'K1', 'K0', 'K1'],\r\n 'A': ['A0', 'A1', 'A2', 'A3'],\r\n 'B': ['B0', 'B1', 'B2', 'B3']})\r\n \r\nright = pd.DataFrame({'key1': ['K0', 'K1', 'K1', 'K2'],\r\n 'key2': ['K0', 'K0', 'K0', 'K0'],\r\n 'C': ['C0', 'C1', 'C2', 'C3'],\r\n 'D': ['D0', 'D1', 'D2', 'D3']})",
"_____no_output_____"
],
[
"pd.merge(left, right, on=['key1', 'key2'])",
"_____no_output_____"
],
[
"pd.merge(left, right, how='outer', on=['key1', 'key2'])",
"_____no_output_____"
],
[
"pd.merge(left, right, how='right', on=['key1', 'key2'])",
"_____no_output_____"
],
[
"pd.merge(left, right, how='left', on=['key1', 'key2'])",
"_____no_output_____"
]
],
[
[
"## Joining\nJoining is a convenient method for combining the columns of two potentially differently-indexed DataFrames into a single result DataFrame.",
"_____no_output_____"
]
],
[
[
"left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],\r\n 'B': ['B0', 'B1', 'B2']},\r\n index=['K0', 'K1', 'K2']) \r\n\r\nright = pd.DataFrame({'C': ['C0', 'C2', 'C3'],\r\n 'D': ['D0', 'D2', 'D3']},\r\n index=['K0', 'K2', 'K3'])",
"_____no_output_____"
],
[
"left.join(right)",
"_____no_output_____"
],
[
"left.join(right, how='outer')",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
]
] |
ecea04d20dc327aed83177f0f181dd61cadcd9a5 | 3,525 | ipynb | Jupyter Notebook | Project5.ipynb | akashgh0sh2807/Project-Euler | de0542a59c56918408b263885dcb6d84d25339d1 | [
"Apache-2.0"
] | null | null | null | Project5.ipynb | akashgh0sh2807/Project-Euler | de0542a59c56918408b263885dcb6d84d25339d1 | [
"Apache-2.0"
] | null | null | null | Project5.ipynb | akashgh0sh2807/Project-Euler | de0542a59c56918408b263885dcb6d84d25339d1 | [
"Apache-2.0"
] | null | null | null | 23.5 | 119 | 0.455887 | [
[
[
"# Project 5\n## Smallest multiple\n2520 is the smallest number that can be divided by each of the numbers from 1 to 10 without any remainder.\n\nWhat is the smallest positive number that is evenly divisible by all of the numbers from 1 to 20?",
"_____no_output_____"
],
[
"## To do list\n\n* Create a function to check divisibility from 11 to 20.\n* Give it a starting point.\n* Create a loop to run the function.\n* Printing the result.\n\n\n",
"_____no_output_____"
],
[
"## Divisibility checker\nCreated a function to check if a number is divisible by 11 to 20.",
"_____no_output_____"
]
],
[
[
"def dividend(number):\n for x in range(11, 21, 1):\n if number % x != 0:\n return False\n return True",
"_____no_output_____"
]
],
[
[
"## Starting point\nCreated a value which is the smallest number divisible by all number from 1 to 10.",
"_____no_output_____"
]
],
[
[
"value = 2520",
"_____no_output_____"
]
],
[
[
"## While loop\nCreated a loop in which if function fails, then adds 20 in it.",
"_____no_output_____"
]
],
[
[
"while not dividend(value):\n value += 20",
"_____no_output_____"
]
],
[
[
"## Printing result\nPrinting the smallest no. which is divisible by 1 to 20.",
"_____no_output_____"
]
],
[
[
"print(\"Smallest number which is divisible by all number from 1 to 20 is:\", value)",
"Smallest number which is divisible by all number from 1 to 20 is: 232792560\n"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
ecea05a83178d6a0d879bec60d2e8237517c565d | 6,151 | ipynb | Jupyter Notebook | content/python/basics/indexing_and_slicing_numpy_arrays.ipynb | vedraiyani/notes-1 | 85b86787e5bdb9c5b4160438c026391c7c8c3a48 | [
"CC0-1.0"
] | 1 | 2019-06-17T19:46:34.000Z | 2019-06-17T19:46:34.000Z | content/python/basics/indexing_and_slicing_numpy_arrays.ipynb | vedraiyani/notes-1 | 85b86787e5bdb9c5b4160438c026391c7c8c3a48 | [
"CC0-1.0"
] | null | null | null | content/python/basics/indexing_and_slicing_numpy_arrays.ipynb | vedraiyani/notes-1 | 85b86787e5bdb9c5b4160438c026391c7c8c3a48 | [
"CC0-1.0"
] | null | null | null | 23.299242 | 269 | 0.52463 | [
[
[
"---\ntitle: \"Indexing And Slicing NumPy Arrays\"\nauthor: \"Chris Albon\"\ndate: 2017-12-20T11:53:49-07:00\ndescription: \"Indexing and slicing NumPy arrays in Python.\"\ntype: technical_note\ndraft: false\n---",
"_____no_output_____"
]
],
[
[
"## Slicing Arrays",
"_____no_output_____"
],
[
"### Explanation Of Broadcasting",
"_____no_output_____"
],
[
"Unlike many other data types, slicing an array into a new variable means that any chances to that new variable are broadcasted to the original variable. Put other way, a slice is a hotlink to the original array variable, not a seperate and independent copy of it.",
"_____no_output_____"
]
],
[
[
"# Import Modules\nimport numpy as np",
"_____no_output_____"
],
[
"# Create an array of battle casualties from the first to the last battle\nbattleDeaths = np.array([1245, 2732, 3853, 4824, 5292, 6184, 7282, 81393, 932, 10834])",
"_____no_output_____"
],
[
"# Divide the array of battle deaths into start, middle, and end of the war\nwarStart = battleDeaths[0:3]; print('Death from battles at the start of war:', warStart)\nwarMiddle = battleDeaths[3:7]; print('Death from battles at the middle of war:', warMiddle)\nwarEnd = battleDeaths[7:10]; print('Death from battles at the end of war:', warEnd)",
"Death from battles at the start of war: [1245 2732 3853]\nDeath from battles at the middle of war: [4824 5292 6184 7282]\nDeath from battles at the end of war: [81393 932 10834]\n"
],
[
"# Change the battle death numbers from the first battle\nwarStart[0] = 11101",
"_____no_output_____"
],
[
"# View that change reflected in the warStart slice of the battleDeaths array\nwarStart",
"_____no_output_____"
],
[
"# View that change reflected in (i.e. \"broadcasted to) the original battleDeaths array\nbattleDeaths",
"_____no_output_____"
]
],
[
[
"## Indexing Arrays",
"_____no_output_____"
],
[
"Note: This multidimensional array behaves like a dataframe or matrix (i.e. columns and rows)",
"_____no_output_____"
]
],
[
[
"# Create an array of regiment information\nregimentNames = ['Nighthawks', 'Sky Warriors', 'Rough Riders', 'New Birds']\nregimentNumber = [1, 2, 3, 4]\nregimentSize = [1092, 2039, 3011, 4099]\nregimentCommander = ['Mitchell', 'Blackthorn', 'Baker', 'Miller']\n\nregiments = np.array([regimentNames, regimentNumber, regimentSize, regimentCommander])\nregiments",
"_____no_output_____"
],
[
"# View the first column of the matrix\nregiments[:,0]",
"_____no_output_____"
],
[
"# View the second row of the matrix\nregiments[1,]",
"_____no_output_____"
],
[
"# View the top-right quarter of the matrix\nregiments[:2,2:]",
"_____no_output_____"
]
]
] | [
"raw",
"markdown",
"code",
"markdown",
"code"
] | [
[
"raw"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code"
]
] |
ecea0a34e4622e106827027ad3328e06cb2ac0c5 | 1,034,959 | ipynb | Jupyter Notebook | Tarea7/.ipynb_checkpoints/T07_MC_Esteban_Reyes-checkpoint.ipynb | esteban-rs/Machine-Learning-I-CIMAT-2021 | 118ff1f4031c4ebe0ecd90b5585c953bd9113d3c | [
"MIT"
] | null | null | null | Tarea7/.ipynb_checkpoints/T07_MC_Esteban_Reyes-checkpoint.ipynb | esteban-rs/Machine-Learning-I-CIMAT-2021 | 118ff1f4031c4ebe0ecd90b5585c953bd9113d3c | [
"MIT"
] | null | null | null | Tarea7/.ipynb_checkpoints/T07_MC_Esteban_Reyes-checkpoint.ipynb | esteban-rs/Machine-Learning-I-CIMAT-2021 | 118ff1f4031c4ebe0ecd90b5585c953bd9113d3c | [
"MIT"
] | 1 | 2022-03-19T19:58:47.000Z | 2022-03-19T19:58:47.000Z | 647.658949 | 482,012 | 0.939134 | [
[
[
"# WGAN: Redes Generadoras Antagónicas Convolucionales Profundas con Métrica Wasserstein\n\n## Aprendizaje Profundo I\n\n### Esteban Reyes Saldaña",
"_____no_output_____"
],
[
"El modelo de redes profundas Redes Antagónicas Generadoras (Generative Adversarial Networks, GANs) fué propuesto por Goodfellow et al., 2014b. Las GANs son un modelo generador (de los muchos que existen) que se basa en redes neuronales profundas.\n\n\nEn esta sección reformularemos el modelo de la GAN basadas en Perceptrones Multicapa a Convolucionales (Radford and Metz, 2015). La siguiente figura ilustra (a manera de recordatorio) la arquitectura de una red convolucional. Detalles de implementación en Keras pueden encontrarse en Dumoulin and Visin (2016), notas convnets 1, notes convnets 2 y Chollet (2018)",
"_____no_output_____"
],
[
"El modelo general seguirá siendo el de una GAN: un generador y un discriminador. El propósito del Generador $ G $ es generar datos sintéticos $ \\tilde{x} $ que sean indistinguibles de los datos reales para el Discriminador $ D $. Por lo que el discriminador es una red que clasifica datos que se le presentan entre reales o falsos (fakes). La siguiente figura representa una GAN.",
"_____no_output_____"
],
[
"",
"_____no_output_____"
],
[
"Función Objetivo de la WGAN",
"_____no_output_____"
],
[
"Sean $ y \\in \\{0,1\\} $ la etiqueta del dato $ x $ correspondientes a “falso” o “real” y $ \\hat{y} \\in [0,1] $ su estimación obtenida del discriminador para el dato en cuestión. Luego, la función a optimizar mediante el entrenamiento de la WGAN esta dada por\n\n$$ L = \\dfrac{1}{n} || W (v, \\hat{v}) ||^2 $$\n\ncon\n\n$$ W(v, \\hat{v} ) = \\dfrac{1}{\\# B} \\sum_{i \\in B} v_{ij} - \\dfrac{1}{\\# \\hat{B}} \\sum_{i \\in \\hat{B}} \\hat{v}_{ij}$$\n\ndonde $B$ define al conjunto de imágenes reales y $\\hat{B} $ al conjunto de imágenes generadas.",
"_____no_output_____"
]
],
[
[
"import os\nimport tensorflow as tf\nimport sys\nimport numpy as np\nimport matplotlib.pyplot as plt\n\nfrom tensorflow.keras.datasets import mnist\nfrom tensorflow.keras.layers import Input, Dense, Reshape, Flatten, Dropout\nfrom tensorflow.keras.layers import BatchNormalization, ZeroPadding2D\nfrom tensorflow.keras.layers import Activation, LeakyReLU\nfrom tensorflow.keras.layers import Conv2D, Conv2DTranspose\n\nfrom tensorflow.keras.models import Sequential, Model\nfrom tensorflow.keras.optimizers import Adam",
"_____no_output_____"
],
[
"from tensorflow.keras.datasets import cifar10",
"_____no_output_____"
],
[
"def reset_weights(model):\n '''\n Reinicializa los pesos del modelo \n '''\n for ix, layer in enumerate(model.layers):\n if hasattr(model.layers[ix], 'kernel_initializer') and \\\n hasattr(model.layers[ix], 'bias_initializer'):\n weight_initializer = model.layers[ix].kernel_initializer\n bias_initializer = model.layers[ix].bias_initializer\n\n old_weights, old_biases = model.layers[ix].get_weights()\n\n model.layers[ix].set_weights([\n weight_initializer(shape=old_weights.shape),\n bias_initializer (shape =len(old_biases))])",
"_____no_output_____"
]
],
[
[
"# Lectura de Datos",
"_____no_output_____"
]
],
[
[
"'''\n# normalización\nx_train = x_train.astype('float32') / 255.\nx_test = x_test.astype('float32') / 255.\n'''",
"_____no_output_____"
]
],
[
[
"Lee los datos reales y pone variables globales",
"_____no_output_____"
]
],
[
[
"# carga datos reales \n(X_train, y_train), (X_test, y_test) = cifar10.load_data()",
"_____no_output_____"
],
[
"# Normalización\nX_train = X_train.astype(np.float32) / 255.\nX_test = X_test.astype(np.float32) / 255.\n\ny_train = y_train.astype(np.float32)\ny_test = y_test.astype(np.float32)",
"_____no_output_____"
],
[
"'''# carga datos reales \n(X_train, y_train), (X_test, y_test) = mnist.load_data()\n\n# Rescale -1 to 1\nX_train = X_train.astype(np.float32) / 127.5 - 1.\nX_train = np.expand_dims(X_train, axis=3)\n\nX_test = X_test.astype(np.float32) / 127.5 - 1.\nX_test = np.expand_dims(X_test, axis = 3)\n\ny_train = y_train.astype(np.float32)\ny_test = y_test.astype(np.float32)'''",
"_____no_output_____"
],
[
"# Dimensión de imágenes\nX_train.shape",
"_____no_output_____"
]
],
[
[
"# Variables globales",
"_____no_output_____"
]
],
[
[
"(buffer_size,img_rows, img_cols, channels) = X_train.shape\nimg_shape = (img_rows, img_cols, channels)\nz_dim = 100 # dimensión del espacio latente\nnum_images = buffer_size\nnum_classes = 10\nbatch_size = 64\nnum_epochs = 100\neach_save = 5\nsave_epochs = 5 * each_save\nlearning_rate = 1e-3\n\n\npath_results = 'dcgan_results/'\npath_checkpoints = 'dcgan_results/checkpoints/'\n\nbatches_per_epoch = num_images // batch_size\n\nnum_images, batches_per_epoch",
"_____no_output_____"
]
],
[
[
"# Generador de datos",
"_____no_output_____"
]
],
[
[
"train_dataset = tf.data.Dataset.from_tensor_slices((X_train, y_train)).shuffle(buffer_size).batch(batch_size)\ntrain_dataset",
"_____no_output_____"
]
],
[
[
"# Generador",
"_____no_output_____"
],
[
"En generador es una red convolucional que\n\n1. Toma como entrada un vector aleatorio de 20 entradas.\n\n2. El cuál es pasado por una capa densa de dimensiones $(7)(7)(256)$ y luego reformateado (reshape) a un tensor de forma $ 7 \\times 7 \\times 256 $.\n\n3. Luego es pasado a una convolución transpuesta que convierte el tensor $ 7 \\times 7 \\times 256 $ en uno de $ 14 \\times 14 \\times 128 $. Con posterior normalización or lotes y actrivación ReLU.\n\n3. Luego es pasado a una convolución transpuesta que convierte el tensor $ 14 \\times 14 \\times 128 $ en uno de $ 14 \\times 14 \\times 64$. Con posterior normalización or lotes y actrivación ReLU.\n\n4. Y de nuevo usando una convolución transpuesta se transforma el tensor $ 14 \\times 14 \\times 64 $ en uno del tamaño de la imagen de salida $ 28 \\times 28 \\times 1 $ a la que se la aplica una activación tanh.\n\nEsto se ilustra en la siguiente figura",
"_____no_output_____"
],
[
"",
"_____no_output_____"
]
],
[
[
"from tensorflow.keras.utils import plot_model\n\ndef build_generator(img_shape, z_dim, verbose=False):\n '''\n Genera una imagen de 28x28x1 a partir de un vector aleatorio de 100 entradas (espacio latente)\n '''\n # Batch de datos\n z = Input(shape=(z_dim,))\n # Pasa entrada unidimensional de dimensión 20 en un tensor de (7)(7)(256) tensor via un red Densa\n # luego la reformatea en un tensor de 7x7x128\n X = Dense(256 * 8 * 8, input_dim=z_dim) (z)\n X = Reshape((8, 8, 256))(X)\n\n # Convolución transpuesta, tensor de 7x7x256 a 14x14x128, con normalización por lote y activación ReLU\n X = Conv2DTranspose(filters = 128, \n kernel_size = 3, \n strides = 2, \n padding = 'same')(X)\n X = BatchNormalization()(X)\n X = LeakyReLU(alpha = 0.01)(X)\n \n # Convolución transpuesta, tensor de 14x14x128, a 14x14x64 con normalización por lote y activación ReLU\n X = Conv2DTranspose(filters = 64, \n kernel_size = 3, \n strides = 1, \n padding = 'same')(X)\n X = BatchNormalization()(X)\n X = LeakyReLU(alpha=0.01)(X)\n \n # Convolución transpuesta, tensor de 14x14x128 a 28x28x1, con activación tahn\n Y = Conv2DTranspose(filters = 3, \n kernel_size = 3, \n strides = 2, \n padding = 'same',\n activation = 'tanh')(X)\n\n \n\n generator_model = Model(inputs = z, outputs = [Y], name ='generator')\n \n return generator_model",
"_____no_output_____"
],
[
"generator = build_generator(img_shape, z_dim)\ngenerator.summary()",
"Model: \"generator\"\n_________________________________________________________________\nLayer (type) Output Shape Param # \n=================================================================\ninput_73 (InputLayer) [(None, 100)] 0 \n_________________________________________________________________\ndense_47 (Dense) (None, 16384) 1654784 \n_________________________________________________________________\nreshape_22 (Reshape) (None, 8, 8, 256) 0 \n_________________________________________________________________\nconv2d_transpose_66 (Conv2DT (None, 16, 16, 128) 295040 \n_________________________________________________________________\nbatch_normalization_140 (Bat (None, 16, 16, 128) 512 \n_________________________________________________________________\nleaky_re_lu_188 (LeakyReLU) (None, 16, 16, 128) 0 \n_________________________________________________________________\nconv2d_transpose_67 (Conv2DT (None, 16, 16, 64) 73792 \n_________________________________________________________________\nbatch_normalization_141 (Bat (None, 16, 16, 64) 256 \n_________________________________________________________________\nleaky_re_lu_189 (LeakyReLU) (None, 16, 16, 64) 0 \n_________________________________________________________________\nconv2d_transpose_68 (Conv2DT (None, 32, 32, 3) 1731 \n=================================================================\nTotal params: 2,026,115\nTrainable params: 2,025,731\nNon-trainable params: 384\n_________________________________________________________________\n"
]
],
[
[
"## Agregando etiquetas\n",
"_____no_output_____"
],
[
"Necesitamos que nuestro generador tenga también información de las etiquetas generadas de manera aleatoria, para ello, pedimos que este modelo reciba dos entradas\n1. El lote de imágenes falsas.\n2. Las etiquetas generadas.\n\nLuego vamos a combinar esta información en una capa que codifique dichas etiquetas por categorías para luego pasarlas al resto de las capas. El modelo se ilustra a continuación",
"_____no_output_____"
],
[
"",
"_____no_output_____"
]
],
[
[
"def build_generator(img_shape, z_dim, verbose=False):\n '''\n Genera una imagen de 28x28x1 a partir de un vector aleatorio de 100 entradas (espacio latente)\n '''\n # Batch de datos\n z = Input(shape=(z_dim,))\n # batch de etiquetas\n image_class = Input(shape = (1,), dtype = np.float32)\n\n # 10 clases en MNIST\n cls = Flatten()(tf.keras.layers.Embedding(10, z_dim)(image_class))\n # hadamard product between z-space and a class conditional embedding\n h = tf.keras.layers.Multiply()([z, cls])\n\n # Pasa entrada unidimensional de dimensión 20 en un tensor de (7)(7)(256) tensor via un red Densa\n # luego la reformatea en un tensor de 7x7x128\n X = Dense(256 * 7 * 7, input_dim=z_dim) (h)\n X = Reshape((7, 7, 256))(X)\n\n # Convolución transpuesta, tensor de 7x7x256 a 14x14x128, con normalización por lote y activación ReLU\n X = Conv2DTranspose(filters = 128, \n kernel_size = 3, \n strides = 2, \n padding = 'same')(X)\n X = BatchNormalization()(X)\n X = LeakyReLU(alpha = 0.01)(X)\n \n # Convolución transpuesta, tensor de 14x14x128, a 14x14x64 con normalización por lote y activación ReLU\n X = Conv2DTranspose(filters = 64, \n kernel_size = 3, \n strides = 1, \n padding = 'same')(X)\n X = BatchNormalization()(X)\n X = LeakyReLU(alpha=0.01)(X)\n \n # Convolución transpuesta, tensor de 14x14x128 a 28x28x1, con activación tahn\n Y = Conv2DTranspose(filters = 1, \n kernel_size = 3, \n strides = 2, \n padding = 'same',\n activation = 'tanh')(X)\n\n \n\n generator_model = Model(inputs = [z, image_class], outputs = [Y], name ='generator')\n \n return generator_model",
"_____no_output_____"
]
],
[
[
"Construye Generador",
"_____no_output_____"
]
],
[
[
"generator = build_generator(img_shape, z_dim)\ngenerator.summary()",
"Model: \"generator\"\n__________________________________________________________________________________________________\nLayer (type) Output Shape Param # Connected to \n==================================================================================================\ninput_31 (InputLayer) [(None, 1)] 0 \n__________________________________________________________________________________________________\nembedding (Embedding) (None, 1, 100) 1000 input_31[0][0] \n__________________________________________________________________________________________________\ninput_30 (InputLayer) [(None, 100)] 0 \n__________________________________________________________________________________________________\nflatten_20 (Flatten) (None, 100) 0 embedding[0][0] \n__________________________________________________________________________________________________\nmultiply (Multiply) (None, 100) 0 input_30[0][0] \n flatten_20[0][0] \n__________________________________________________________________________________________________\ndense_19 (Dense) (None, 12544) 1266944 multiply[0][0] \n__________________________________________________________________________________________________\nreshape_9 (Reshape) (None, 7, 7, 256) 0 dense_19[0][0] \n__________________________________________________________________________________________________\nconv2d_transpose_27 (Conv2DTran (None, 14, 14, 128) 295040 reshape_9[0][0] \n__________________________________________________________________________________________________\nbatch_normalization_58 (BatchNo (None, 14, 14, 128) 512 conv2d_transpose_27[0][0] \n__________________________________________________________________________________________________\nleaky_re_lu_78 (LeakyReLU) (None, 14, 14, 128) 0 batch_normalization_58[0][0] \n__________________________________________________________________________________________________\nconv2d_transpose_28 (Conv2DTran (None, 14, 14, 64) 73792 leaky_re_lu_78[0][0] \n__________________________________________________________________________________________________\nbatch_normalization_59 (BatchNo (None, 14, 14, 64) 256 conv2d_transpose_28[0][0] \n__________________________________________________________________________________________________\nleaky_re_lu_79 (LeakyReLU) (None, 14, 14, 64) 0 batch_normalization_59[0][0] \n__________________________________________________________________________________________________\nconv2d_transpose_29 (Conv2DTran (None, 28, 28, 1) 577 leaky_re_lu_79[0][0] \n==================================================================================================\nTotal params: 1,638,121\nTrainable params: 1,637,737\nNon-trainable params: 384\n__________________________________________________________________________________________________\n"
]
],
[
[
"# Discriminador",
"_____no_output_____"
],
[
"En discriminador es una red neuronal secuencial profunda que recibe de entrada un vector datos y produce una clasificación indicando si los datos son reales o falsos (fake).",
"_____no_output_____"
],
[
"",
"_____no_output_____"
]
],
[
[
"def build_discriminator(img_shape, verbose=False):\n Xin = Input(shape=(img_shape[0],img_shape[1],img_shape[2],))\n # Convolución2D tensor de 28x28x1 a 14x14x32 y activación Leaky ReLU\n X = Conv2D(filters = 32, \n kernel_size = 3, \n strides = 2, \n input_shape = img_shape, \n padding = 'same')(Xin)\n #X = BatchNormalization()(X)\n X = LeakyReLU(alpha = 0.01)(X)\n\n # Convolución2D tensor de 14x14x32 a 7x7x64, con normalización por lote y activación Leaky ReLU\n X = Conv2D(filters = 64, \n kernel_size = 3, \n strides = 2, \n padding = 'same')(X)\n X = BatchNormalization()(X)\n X = LeakyReLU(alpha = 0.01)(X)\n \n # Convolución2D tensor de 7x7x64 a 3x3x128, con normalización por lote y activación Leaky ReLU\n X = Conv2D(filters = 128, \n kernel_size = 3, \n strides = 2, \n padding = 'same')(X)\n X = BatchNormalization()(X)\n X = LeakyReLU(alpha = 0.01)(X)\n\n # Aplanado del tensor, y capa densa de salida de clasificacion con activación sigmoide\n X = Flatten()(X)\n\n fake = Dense(1, activation = 'linear', name = 'generator')(X) \n # aux = Dense(10, activation = 'softmax', name = 'auxiliary')(X)\n\n \n discriminator_model = Model(inputs = Xin, outputs = [fake], name ='discriminator')\n\n return discriminator_model",
"_____no_output_____"
]
],
[
[
"## Construye y compila el Discriminador\n",
"_____no_output_____"
]
],
[
[
"# construye el discriminador \ndiscriminator = build_discriminator(img_shape)\ndiscriminator.summary()",
"Model: \"discriminator\"\n_________________________________________________________________\nLayer (type) Output Shape Param # \n=================================================================\ninput_74 (InputLayer) [(None, 32, 32, 3)] 0 \n_________________________________________________________________\nconv2d_144 (Conv2D) (None, 16, 16, 32) 896 \n_________________________________________________________________\nleaky_re_lu_190 (LeakyReLU) (None, 16, 16, 32) 0 \n_________________________________________________________________\nconv2d_145 (Conv2D) (None, 8, 8, 64) 18496 \n_________________________________________________________________\nbatch_normalization_142 (Bat (None, 8, 8, 64) 256 \n_________________________________________________________________\nleaky_re_lu_191 (LeakyReLU) (None, 8, 8, 64) 0 \n_________________________________________________________________\nconv2d_146 (Conv2D) (None, 4, 4, 128) 73856 \n_________________________________________________________________\nbatch_normalization_143 (Bat (None, 4, 4, 128) 512 \n_________________________________________________________________\nleaky_re_lu_192 (LeakyReLU) (None, 4, 4, 128) 0 \n_________________________________________________________________\nflatten_50 (Flatten) (None, 2048) 0 \n_________________________________________________________________\ngenerator (Dense) (None, 1) 2049 \n=================================================================\nTotal params: 96,065\nTrainable params: 95,681\nNon-trainable params: 384\n_________________________________________________________________\n"
]
],
[
[
"# Crítico Wasserstein",
"_____no_output_____"
],
[
"De manera similar al generador, necesitamos que el crítico conozca las etiquetas generadas, para ellos se las damos de manera similar a como se hizo en el generador",
"_____no_output_____"
],
[
"",
"_____no_output_____"
]
],
[
[
"def build_Wasserstein_critic(img_shape, verbose = False):\n Xin = Input(shape=(img_shape[0],img_shape[1],img_shape[2],))\n '''# Agrego clase de vector\n image_class = Input(shape = (1,), dtype = np.float32)\n # 10 clases en MNIST\n cls = Flatten()(tf.keras.layers.Embedding(10, z_dim)(image_class))\n # hadamard product between z-space and a class conditional embedding\n h = tf.keras.layers.Multiply()([Xin, cls])'''\n\n # Convolución2D tensor de 28x28x1 a 14x14x32 y activación Leaky ReLU\n X = Conv2D(filters = 32, \n kernel_size = 3, \n strides = 2, \n input_shape = img_shape, \n padding = 'same')(Xin)\n #X = BatchNormalization()(X)\n X = LeakyReLU(alpha = 0.01)(X)\n\n # Convolución2D tensor de 14x14x32 a 7x7x64, con normalización por lote y activación Leaky ReLU\n X = Conv2D(filters = 64, \n kernel_size = 3, \n strides = 2, \n padding = 'same')(X)\n X = BatchNormalization()(X)\n X = LeakyReLU(alpha = 0.01)(X)\n \n # Convolución2D tensor de 7x7x64 a 3x3x128, con normalización por lote y activación Leaky ReLU\n X = Conv2D(filters = 128, \n kernel_size = 3, \n strides = 2, \n padding = 'same')(X)\n X = BatchNormalization()(X)\n X = LeakyReLU(alpha = 0.01)(X)\n\n # Aplanado del tensor, y capa densa de salida de clasificacion con activación sigmoide\n Y_out1 = Flatten()(X)\n Y_out2 = Dense(1, activation='sigmoid')(Y_out1)\n\n critic_model = Model(inputs = Xin, outputs = [Y_out2], name ='critic')\n\n return critic_model",
"_____no_output_____"
],
[
"# construye el discriminador \nwasserstein_critic = build_Wasserstein_critic(img_shape)\nwasserstein_critic.summary()",
"Model: \"critic\"\n_________________________________________________________________\nLayer (type) Output Shape Param # \n=================================================================\ninput_75 (InputLayer) [(None, 32, 32, 3)] 0 \n_________________________________________________________________\nconv2d_147 (Conv2D) (None, 16, 16, 32) 896 \n_________________________________________________________________\nleaky_re_lu_193 (LeakyReLU) (None, 16, 16, 32) 0 \n_________________________________________________________________\nconv2d_148 (Conv2D) (None, 8, 8, 64) 18496 \n_________________________________________________________________\nbatch_normalization_144 (Bat (None, 8, 8, 64) 256 \n_________________________________________________________________\nleaky_re_lu_194 (LeakyReLU) (None, 8, 8, 64) 0 \n_________________________________________________________________\nconv2d_149 (Conv2D) (None, 4, 4, 128) 73856 \n_________________________________________________________________\nbatch_normalization_145 (Bat (None, 4, 4, 128) 512 \n_________________________________________________________________\nleaky_re_lu_195 (LeakyReLU) (None, 4, 4, 128) 0 \n_________________________________________________________________\nflatten_51 (Flatten) (None, 2048) 0 \n_________________________________________________________________\ndense_48 (Dense) (None, 1) 2049 \n=================================================================\nTotal params: 96,065\nTrainable params: 95,681\nNon-trainable params: 384\n_________________________________________________________________\n"
]
],
[
[
"# Modelo Completo",
"_____no_output_____"
],
[
"El modelo completo se ve como",
"_____no_output_____"
],
[
"",
"_____no_output_____"
],
[
"# Funciones de Pérdida",
"_____no_output_____"
]
],
[
[
"# Funciones clásicas\ncross_entropy = tf.keras.losses.BinaryCrossentropy(from_logits=True)\nmae = tf.keras.losses.MeanAbsoluteError(name='mean_absolute_error')",
"_____no_output_____"
],
[
"Lambda = [0.5, 1.0]\n\ndef generator_loss_classic(fake_output) :\n return cross_entropy(tf.ones_like(fake_output), fake_output)\n\ndef generator_loss_v2(real_output, fake_output) :\n return - tf.keras.backend.log(tf.reduce_mean(fake_output))\n\ndef generator_loss(real_output, fake_output) :\n return tf.keras.backend.log(1.0 - tf.reduce_mean(fake_output))\n\ndef discriminator_loss_classic(real_output, fake_output) :\n # Pérdida de los verdaderos (1 vs y_hat)\n real_loss = cross_entropy(tf.ones_like(real_output), real_output)\n # Pérdida de los sintéticos (0 vs y_hat)\n fake_loss = cross_entropy(tf.zeros_like(real_output), real_output)\n # Suma de los dos tipos de errores\n total_loss = real_loss + fake_loss\n return total_loss\n\ndef discriminator_loss_v2 (real_output, fake_output) :\n # Pérdida de los verdaderos (1 vs y_hat)\n return tf.keras.backend.log(tf.reduce_mean(fake_output)) - tf.keras.backend.log(tf.reduce_mean(real_output))\n\ndef discriminator_loss(real_output, fake_output) :\n # Pérdida de los valores ( 1 vs y_hat)\n return - tf.keras.backend.log(tf.reduce_mean(real_output) * (1.0 - tf.reduce_mean(fake_output)))",
"_____no_output_____"
]
],
[
[
"## Implementación de la nueva función de pérdida",
"_____no_output_____"
]
],
[
[
"def wasserstein_generator_loss (real_output, fake_output) :\n lossEM = tf.reduce_mean(tf.math.abs(tf.reduce_mean(real_output[0], 0) - tf.reduce_mean(fake_output[0], 0)))\n lossC = tf.keras.backend.log(1.0 - tf.reduce_mean(fake_output[1]))\n return Lambda[0] * lossEM + Lambda[1] * lossC\n\ndef wasserstein_critic_loss(real_output, fake_output) :\n lossEM = tf.reduce_mean(tf.math.abs(tf.reduce_mean(real_output[0], 0) - tf.reduce_mean(fake_output[0], 0)))\n lossC = - tf.keras.backend.log( tf.reduce_mean(real_output[1]) * (1.0 - tf.reduce_mean(fake_output[1])))\n return Lambda[0] * lossEM + Lambda[1] * lossC",
"_____no_output_____"
]
],
[
[
"## Creamos modelos",
"_____no_output_____"
]
],
[
[
"Losses = {'dcgan' : {'generator' : generator_loss,\n 'discriminator' : discriminator_loss},\n 'wgan' : {'generator' : wasserstein_generator_loss,\n 'discriminator' : wasserstein_critic_loss}\n }\nModels = {'dcgan' : {'generator' : generator,\n 'discriminator' : discriminator},\n 'wgan' : {'generator' : generator,\n 'discriminator' : wasserstein_critic}\n }\n\n# Para el paso de entrenamiento\nmodelname = 'wgan'\nGAN_discriminator = Models[modelname]['discriminator']\nGAN_generator = Models[modelname]['generator']\n# Pérdidas\nLoss_discriminator = Losses[modelname]['discriminator']\nLoss_generator = Losses[modelname]['generator']",
"_____no_output_____"
]
],
[
[
"# Paso de entrenamiento",
"_____no_output_____"
],
[
"Definiremos un paso de entrenamiento de la GAN, que corresponde a hacer un paso de entrenamiento en cada modelo.\n\n1. Carga lote de imágenes reales $ X $ y etiquetas $y$.\n\n2. Genera un lote de variables latentes $ Z $\n\n3. Genera un lote de variables sintéticas: $ \\hat{X} = G(Z; \\theta_g) $\n\n4. Calcula las predicciones para $ \\hat {Y} = D([X | \\hat{X}], \\theta_d) $\n\n5. Calcula costos $ J^D $ y $ J^G$.\n\n6. Calcula gradientes $\\nabla_{\\theta_d} J^D$ y $ \\nabla_{\\theta_g} J^G$ .\n\n7. Actualiza pesos con un paso del algoritmo de optimización:\n\n$$ \\theta_d = \\theta_d + \\delta(\\nabla_{\\theta_d} J^D) $$ \n$$ \\theta_g = \\theta_g + \\delta(\\nabla_{\\theta_g} J^G)$$ \n\ndonde $\\delta(\\cdot)$ representa el paso del algoritmo utilizado.",
"_____no_output_____"
]
],
[
[
"#El decorador `tf.function` indica que la función se \"compila\" para que pueda incluirse en un gráfo de calculo.\[email protected]\ndef train_step(images = None, labels = None, modelname = 'dcgan'):\n '''\n Implementa un paso de entrenamiento para la GAN\n \n Recibe como parámetros un semi-lote de imágenes reales\n '''\n\n # variables latentes (ruido Gaussiano), tantas como imagenes reales\n z = tf.random.normal([images.shape[0], z_dim])\n sampled_labels = np.random.randint(0, 10, images.shape[0])\n sampled_labels = sampled_labels.reshape((-1, 1))\n\n # Los siguientes pasos registaran (en \"TAPE\") para efectos de calcular gradientes\n # son dos \"Tapes\" para registrar los calculos de cada modelo\n with tf.GradientTape() as gen_tape, tf.GradientTape() as disc_tape:\n # genera el semi-lote de datos sintéticos\n # generated_images = GAN_generator([z,sampled_labels] , training=True)\n generated_images = GAN_generator(z, training=True)\n \n # calcula la predicción para datos verdaderos y falsos\n # real_output = GAN_discriminator([images,labels] , training = True)\n real_output = GAN_discriminator(images, training = True)\n # fake_output = GAN_discriminator([generated_images,sampled_labels], training = True)\n fake_output = GAN_discriminator(generated_images, training = True)\n\n # calcula las pérdidas del Discriminador y del Generador\n disc_loss = Loss_discriminator(real_output, fake_output)\n gen_loss = Loss_generator(real_output, fake_output)\n\n # Para cada modelo, calcula el gradiente de su función de costo respecto a sus pesos entrenables, \n # haciendo retropropagación sobre los calculos realizados\n gradients_of_generator = gen_tape.gradient(gen_loss, GAN_generator.trainable_variables)\n gradients_of_discriminator = disc_tape.gradient(disc_loss, GAN_discriminator.trainable_variables)\n\n # Hace el paso de actualizacion de los pesos\n generator_optimizer.apply_gradients (zip(gradients_of_generator , GAN_generator.trainable_variables))\n discriminator_optimizer.apply_gradients(zip(gradients_of_discriminator, GAN_discriminator.trainable_variables))\n \n return disc_loss, gen_loss",
"_____no_output_____"
]
],
[
[
"# Iteración del entrenamiento",
"_____no_output_____"
]
],
[
[
"from PIL import Image\nimport imageio\nimport glob\n\n# - - - - - - - - - - - - - - - - - - - - - - - - - - \n# Crea una collage de imágenes con el Generador y la guarda\n# - - - - - - - - - - - - - - - - - - - - - - - - - - \n\nnum_img_rows, num_img_cols = (4,4)\nnum_examples_to_generate = num_img_rows * num_img_cols\n\nseed = tf.random.normal([num_examples_to_generate, z_dim])\nlabels_seed = np.random.randint(0, 10, num_examples_to_generate)\nlabels_seed = labels_seed.reshape((-1, 1))\n\ndef generate_and_save_images(model, epoch, test_input, labels, pathdir=path_results):\n # Se pone entrenable en Falso porque esta en modo inferencia el \n # predictions = model([test_input, labels], training=False)\n predictions = model(test_input, training=False)\n # predictions -> [0,255]\n predictions = predictions - tf.reduce_min(predictions)\n predictions = 255 * predictions / tf.reduce_max(predictions)\n data = tf.cast(predictions, tf.uint8)\n\n fig = plt.figure(figsize=(4,4)) \n\n for i in range(data.shape[0]):\n plt.subplot(4, 4, i+1)\n plt.imshow(data[i, :, :, :])\n plt.axis('off')\n\n plt.savefig(pathdir+'image_epch_{:04d}.png'.format(epoch))\n plt.show()\n \n# - - - - - - - - - - - - - - - - - - - - - - - - - - \n# Despliega la imagen correspondiente a una época\n# - - - - - - - - - - - - - - - - - - - - - - - - - - \n\ndef display_image(epoch, pathdir=path_results, modelname = 'dcgan') :\n filename = '{}{}_image_epoch_{:04d}.png',format(pathdir, modelname, epoch)\n\n return Image.open(filename)\n\n# ----------------------------------------------------\n# Crea un gif animado con las imágenes de las épocas\n# ----------------------------------------------------\n\ndef createGif(anim_file = 'gan.gif', pathdir = path_results, modelname = 'dcgan') :\n gifname = '{}{}_{}'.format(pathdir, modelname, anim_file)\n with imageio.get_writer(gifname, mode = 'I') as writer :\n finelames = glob.glob(pathdir + 'image*.png')\n filenames = sorted(finelames)\n for i, filename in enumerate(filenames) :\n image = imageio.imread(filename)\n if i % 5 == 0 :\n writer.append_data(image)\n\nfrom tensorflow.keras.preprocessing.image import load_img, img_to_array\n\ndef saveGif(anim_file = 'gan.gif', pathdir = path_results, modelname = 'dcgan') :\n gifname = '{}{}_{}'.format(pathdir, modelname, anim_file)\n filenames = glob.glob(pathdir + 'image*.png')\n filenames = sorted(filenames)\n\n print(gifname, filenames, len(filenames))\n \n images = []\n for i, filename in enumerate(filenames) :\n images.append(load_img(filename))\n images[1].save(gifname,\n save_all = True,\n append_images = images[2:],\n optimize = False,\n duration = 40,\n loop = 0)",
"_____no_output_____"
]
],
[
[
"# Optimizadores para los modelos",
"_____no_output_____"
]
],
[
[
"generator_optimizer = tf.keras.optimizers.Adam(learning_rate)\ndiscriminator_optimizer = tf.keras.optimizers.Adam(learning_rate)\nlearning_rate",
"_____no_output_____"
],
[
"checkpoint_prefix = os.path.join(path_checkpoints, 'ckpt')",
"_____no_output_____"
],
[
"checkpoint = tf.train.Checkpoint(generator_optimizer = generator_optimizer,\n discriminator_optimizer = discriminator_optimizer,\n GAN_generator = GAN_generator,\n GAN_discriminator = GAN_discriminator)",
"_____no_output_____"
],
[
"from IPython import display\nimport time \nfrom tqdm import tqdm\n\ndef train(dataset, epochs, modelname = 'dcgan'):\n generator_losses = [] \n discriminator_losses = []\n for epoch in range(epochs):\n start = time.time()\n t = 0\n for image_batch, true_label in dataset:\n gen_loss, disc_loss = train_step(images = image_batch, labels = true_label, modelname = modelname)\n\n # solo registramos los costos en el último lote\n generator_losses.append(gen_loss)\n discriminator_losses.append(disc_loss)\n \n # Produce imágenes para crear el GIF\n if (epoch + 1) % each_save == 0:\n display.clear_output(wait = True) # limpia el buffer\n generate_and_save_images(model = generator,\n epoch = epoch + 1,\n test_input = seed,\n labels = labels_seed,\n pathdir = path_results)\n if (epochs + 1) % save_epochs == 0 :\n checkpoint.save(file_prefix = checkpoint_prefix)\n print ('{} : Time for epoch {} is {} sec'.format(modelname, epoch + 1, time.time()-start))\n # Genera conjunto de imágenes para mostrar avances\n display.clear_output(wait = True)\n generate_and_save_images(model = generator,\n epoch = epoch + 1,\n test_input = seed,\n labels = labels_seed,\n pathdir = path_results)\n return np.array(generator_losses), np.array(discriminator_losses)",
"_____no_output_____"
]
],
[
[
"# Entrenamiento de la WGAN",
"_____no_output_____"
],
[
"## Creando el modelo",
"_____no_output_____"
]
],
[
[
"# creo generador\ngenerator = build_generator(img_shape, z_dim)\n# creo discriminador\ndiscriminator = build_discriminator(img_shape)\n# construye el discriminador \nwasserstein_critic = build_Wasserstein_critic(img_shape)\n\nLosses = {'dcgan' : {'generator' : generator_loss,\n 'discriminator' : discriminator_loss},\n 'wgan' : {'generator' : wasserstein_generator_loss,\n 'discriminator' : wasserstein_critic_loss}\n }\nModels = {'dcgan' : {'generator' : generator,\n 'discriminator' : discriminator},\n 'wgan' : {'generator' : generator,\n 'discriminator' : wasserstein_critic}\n }\n\n# Para el paso de entrenamiento\nmodelname = 'wgan'\nGAN_discriminator = Models[modelname]['discriminator']\nGAN_generator = Models[modelname]['generator']\n# Pérdidas\nLoss_discriminator = Losses[modelname]['discriminator']\nLoss_generator = Losses[modelname]['generator']\n\ncheckpoint = tf.train.Checkpoint(generator_optimizer = generator_optimizer,\n discriminator_optimizer = discriminator_optimizer,\n GAN_generator = GAN_generator,\n GAN_discriminator = GAN_discriminator)",
"_____no_output_____"
],
[
"generator_losses, discriminator_losses = train(train_dataset, num_epochs, modelname = 'wgan')",
"_____no_output_____"
]
],
[
[
" Guardo Gifs",
"_____no_output_____"
]
],
[
[
"saveGif('cifar10.gif', pathdir = path_results, modelname = 'wgan')",
"dcgan_results/wgan_cifar10.gif ['dcgan_results/image_epch_0005.png', 'dcgan_results/image_epch_0010.png', 'dcgan_results/image_epch_0015.png', 'dcgan_results/image_epch_0020.png', 'dcgan_results/image_epch_0025.png', 'dcgan_results/image_epch_0030.png', 'dcgan_results/image_epch_0035.png', 'dcgan_results/image_epch_0040.png', 'dcgan_results/image_epch_0045.png', 'dcgan_results/image_epch_0050.png', 'dcgan_results/image_epch_0055.png', 'dcgan_results/image_epch_0060.png', 'dcgan_results/image_epch_0065.png', 'dcgan_results/image_epch_0070.png', 'dcgan_results/image_epch_0075.png', 'dcgan_results/image_epch_0080.png', 'dcgan_results/image_epch_0085.png', 'dcgan_results/image_epch_0090.png', 'dcgan_results/image_epch_0095.png', 'dcgan_results/image_epch_0100.png'] 20\n"
]
],
[
[
"# Salvar modelos y graficar desempeño",
"_____no_output_____"
]
],
[
[
"generator.save_weights('dcgan_generator_2_0.h5')\ndiscriminator.save_weights('dcgan_discriminator_2_0.h5')",
"_____no_output_____"
],
[
"plt.figure(figsize=(12,4))\nplt.subplot(131)\nplt.plot(generator_losses, 'r')\nplt.title('$J^G$')\nplt.subplot(132)\nplt.plot(discriminator_losses, 'g')\nplt.title('$J^D$')\nplt.subplot(133)\nplt.plot(generator_losses+discriminator_losses, 'b')\nplt.title('$J^G+J^D$')\nplt.show()",
"_____no_output_____"
],
[
"",
"_____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",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
]
] |
ecea20d843c3932e1dd179586f4d574a91e4c51b | 48,504 | ipynb | Jupyter Notebook | OLPS_Comparison.ipynb | rosdyana/OLPS-Comparison | b9f0596d07190e43318c3086aefc5822baf34375 | [
"MIT"
] | 4 | 2017-10-31T14:06:12.000Z | 2020-11-05T20:13:59.000Z | OLPS_Comparison.ipynb | rosdyana/OLPS-Comparison | b9f0596d07190e43318c3086aefc5822baf34375 | [
"MIT"
] | null | null | null | OLPS_Comparison.ipynb | rosdyana/OLPS-Comparison | b9f0596d07190e43318c3086aefc5822baf34375 | [
"MIT"
] | 3 | 2017-09-17T09:53:41.000Z | 2022-02-06T19:56:56.000Z | 31.414508 | 983 | 0.592467 | [
[
[
"# Comparing OLPS algorithms on a diversified set of ETFs",
"_____no_output_____"
],
[
"Let's compare the state of the art in OnLine Portfolio Selection (OLPS) algorithms and determine if they can enhance a rebalanced passive strategy in practice. [Online Portfolio Selection: A Survey by Bin Li and Steven C. H. Hoi](http://arxiv.org/abs/1212.2129) provides the most comprehensive review of multi-period portfolio allocation optimization algorithms. The authors [developed](http://olps.stevenhoi.org/) the [OLPS Toolbox]( http://www.mysmu.edu.sg/faculty/chhoi/olps/OLPS_toolbox.pdf), but here we use [Mojmir Vinkler's](https://www.linkedin.com/profile/view?id=210899853) [implementation](https://github.com/Marigold/universal-portfolios) and extend [his comparison](http://nbviewer.ipython.org/github/Marigold/universal-portfolios/blob/master/On-line%20portfolios.ipynb) to a more recent timeline with a set of ETFs to avoid survivorship bias (as suggested by [Ernie Chan](http://epchan.blogspot.cz/2007/01/universal-portfolios.html)) and idiosyncratic risk.\n\nVinkler does all the hard work in his [thesis](http://is.muni.cz/th/358102/prif_m/?lang=en;id=183901), and concludes that Universal Portfolios work practically the same as Constant Rebalanced Portfolios, and work better for an uncorrelated set of small and volatile stocks. Here I'm looking to find if any strategy is applicable to a set of ETFs.\n\nThe agorithms compared are:\n\nType | Name | Algo | Reference \n-------------------------|------|------|----\nBenchmark | BAH | Buy and Hold |\nBenchmark | CRP | Constant Rebalanced Portfolio | T. Cover. [Universal Portfolios](http://www-isl.stanford.edu/~cover/papers/paper93.pdf), 1991.\nBenchmark | UCRP | Uniform CRP (UCRP), a special case of CRP with all weights being equal | T. Cover. [Universal Portfolios](http://www-isl.stanford.edu/~cover/papers/paper93.pdf), 1991.\nBenchmark | BCRP | Best Constant Rebalanced Portfolio | T. Cover. [Universal Portfolios](http://www-isl.stanford.edu/~cover/papers/paper93.pdf), 1991.\nFollow-the-Winner | UP | Universal Portfolio | T. Cover. [Universal Portfolios](http://www-isl.stanford.edu/~cover/papers/paper93.pdf), 1991.\nFollow-the-Winner | EG | Exponential Gradient | Helmbold, David P., et al. [On‐Line Portfolio Selection Using Multiplicative Updates](http://www.cis.upenn.edu/~mkearns/finread/helmbold98line.pdf) Mathematical Finance 8.4 (1998): 325-347.\nFollow-the-Winner | ONS | Online Newton Step | A. Agarwal, E. Hazan, S. Kale, R. E. Schapire. [Algorithms for Portfolio Management based on the Newton Method](http://machinelearning.wustl.edu/mlpapers/paper_files/icml2006_AgarwalHKS06.pdf), 2006.\nFollow-the-Loser | Anticor | Anticorrelation | A. Borodin, R. El-Yaniv, and V. Gogan. [Can we learn to beat the best stock](http://arxiv.org/abs/1107.0036), 2005\nFollow-the-Loser |PAMR | Passive Aggressive Mean Reversion | B. Li, P. Zhao, S. C.H. Hoi, and V. Gopalkrishnan. [Pamr: Passive aggressive mean reversion strategy for portfolio selection](http://www.cais.ntu.edu.sg/~chhoi/paper_pdf/PAMR_ML_final.pdf), 2012.\nFollow-the-Loser |CWMR | Confidence Weighted Mean Reversion | B. Li, S. C. H. Hoi, P. L. Zhao, and V. Gopalkrishnan.[Confidence weighted mean reversion strategy for online portfolio selection](http://jmlr.org/proceedings/papers/v15/li11b/li11b.pdf), 2013. \nFollow-the-Loser | OLMAR | Online Moving Average Reversion| Bin Li and Steven C. H. Hoi [On-Line Portfolio Selection with Moving Average Reversion](http://arxiv.org/abs/1206.4626)\nFollow-the-Loser |RMR | Robust Median Reversion | D. Huang, J. Zhou, B. Li, S. C.vH. Hoi, S. Zhou [Robust Median Reversion Strategy for On-Line Portfolio Selection](http://ijcai.org/papers13/Papers/IJCAI13-296.pdf), 2013.\nPattern Matching | Kelly | Kelly fractional betting |[Kelly Criterion](http://en.wikipedia.org/wiki/Kelly_criterion#Application_to_the_stock_market)\nPattern Matching | BNN | nonparametric nearest neighbor log-optimal | L. Gyorfi, G. Lugosi, and F. Udina. [Nonparametric kernel based sequential investment strategies](http://papers.ssrn.com/sol3/papers.cfm?abstract_id=889976). Mathematical Finance 16 (2006) 337–357.\nPattern Matching | CORN | correlation-driven nonparametric learning | B. Li, S. C. H. Hoi, and V. Gopalkrishnan. [Corn: correlation-driven nonparametric learning approach for portfolio selection](http://www.cais.ntu.edu.sg/~chhoi/paper_pdf/TIST-CORN.pdf), 2011.\n\nWe pick 6 ETFs to avoid survivorship bias and capture broad market diversification. We select the longest running ETF per assset class: [VTI](https://www.google.com/finance?q=VTI), [EFA](https://www.google.com/finance?q=EFA), [EEM](https://www.google.com/finance?q=EFA), [TLT](https://www.google.com/finance?q=TLT), [TIP](https://www.google.com/finance?q=TIP), [VNQ](https://www.google.com/finance?q=VNQ) . We train and select the best parameters on market data from 2005-2012 inclusive (8 years), and test on 2013-2014 inclusive (2 years). ",
"_____no_output_____"
]
],
[
[
"# You will first need to either download or install universal-portfolios from Vinkler\n# one way to do it is uncomment the line below and execute\n#!pip install --upgrade universal-portfolios \n# or\n#!pip install --upgrade -e [email protected]:Marigold/universal-portfolios.git@master#egg=universal-portfolios\n#\n# if the above fail, git clone [email protected]:marigold/universal-portfolios.git and python setup.py install",
"_____no_output_____"
],
[
"#Initialize and set debugging level to `debug` to track progress.",
"_____no_output_____"
],
[
"%matplotlib inline\n\nimport numpy as np\nimport pandas as pd\nfrom pandas_datareader import data as pdr\n# data reader now seperated to new package. pip install pandas-datareader\n#from pandas.io.data import DataReader\nimport fix_yahoo_finance as yf\nyf.pdr_override() # <== that's all it takes :-)\nfrom datetime import datetime\nimport six\nimport universal as up\nfrom universal import tools\nfrom universal import algos\nimport logging\n# we would like to see algos progress\nlogging.basicConfig(format='%(asctime)s %(message)s', level=logging.DEBUG)\n \nimport matplotlib as mpl\nimport matplotlib.pyplot as plt\n\n# we need 14 colors for the plot\n#n_lines = 14\n#color_idx = np.linspace(0, 1, n_lines)\n#mpl.rcParams['axes.color_cycle']=[plt.cm.rainbow(i) for i in color_idx]\n#from cycler import cycler\n#mpl.rcParams['axes.prop_cycle'] = cycler(color='bgrcmyk')\n# Generate random colormap\ndef rand_cmap(nlabels, type='bright', first_color_black=True, last_color_black=False, verbose=True):\n \"\"\"\n Creates a random colormap to be used together with matplotlib. Useful for segmentation tasks\n :param nlabels: Number of labels (size of colormap)\n :param type: 'bright' for strong colors, 'soft' for pastel colors\n :param first_color_black: Option to use first color as black, True or False\n :param last_color_black: Option to use last color as black, True or False\n :param verbose: Prints the number of labels and shows the colormap. True or False\n :return: colormap for matplotlib\n \"\"\"\n from matplotlib.colors import LinearSegmentedColormap\n import colorsys\n import numpy as np\n\n if type not in ('bright', 'soft'):\n print ('Please choose \"bright\" or \"soft\" for type')\n return\n\n if verbose:\n print('Number of labels: ' + str(nlabels))\n\n # Generate color map for bright colors, based on hsv\n if type == 'bright':\n randHSVcolors = [(np.random.uniform(low=0.0, high=1),\n np.random.uniform(low=0.2, high=1),\n np.random.uniform(low=0.9, high=1)) for i in range(nlabels)]\n\n # Convert HSV list to RGB\n randRGBcolors = []\n for HSVcolor in randHSVcolors:\n randRGBcolors.append(colorsys.hsv_to_rgb(HSVcolor[0], HSVcolor[1], HSVcolor[2]))\n\n if first_color_black:\n randRGBcolors[0] = [0, 0, 0]\n\n if last_color_black:\n randRGBcolors[-1] = [0, 0, 0]\n\n random_colormap = LinearSegmentedColormap.from_list('new_map', randRGBcolors, N=nlabels)\n\n # Generate soft pastel colors, by limiting the RGB spectrum\n if type == 'soft':\n low = 0.6\n high = 0.95\n randRGBcolors = [(np.random.uniform(low=low, high=high),\n np.random.uniform(low=low, high=high),\n np.random.uniform(low=low, high=high)) for i in range(nlabels)]\n\n if first_color_black:\n randRGBcolors[0] = [0, 0, 0]\n\n if last_color_black:\n randRGBcolors[-1] = [0, 0, 0]\n random_colormap = LinearSegmentedColormap.from_list('new_map', randRGBcolors, N=nlabels)\n\n # Display colorbar\n if verbose:\n from matplotlib import colors, colorbar\n from matplotlib import pyplot as plt\n fig, ax = plt.subplots(1, 1, figsize=(15, 0.5))\n\n bounds = np.linspace(0, nlabels, nlabels + 1)\n norm = colors.BoundaryNorm(bounds, nlabels)\n\n cb = colorbar.ColorbarBase(ax, cmap=random_colormap, norm=norm, spacing='proportional', ticks=None,\n boundaries=bounds, format='%1i', orientation=u'horizontal')\n\n return random_colormap\n\nmpl.rcParams['figure.figsize'] = (16, 10) # increase the size of graphs\nmpl.rcParams['legend.fontsize'] = 12\nmpl.rcParams['lines.linewidth'] = 1\n#default_color_cycle = mpl.rcParams['axes.color_cycle'] # save this as we will want it back later\nnew_cmap = rand_cmap(100, type='bright', first_color_black=True, last_color_black=False, verbose=True)\ndefault_color_cycle = new_cmap",
"_____no_output_____"
],
[
"# note what versions we are on:\nimport sys\nprint('Python: '+sys.version)\nprint('Pandas: '+pd.__version__)\nimport pkg_resources\nprint('universal-portfolios: '+pkg_resources.get_distribution(\"universal-portfolios\").version)\nprint('Numpy: '+np.__version__)",
"_____no_output_____"
]
],
[
[
"## Loading the data",
"_____no_output_____"
],
[
"We want to train on market data from 2005-2012 inclusive (8 years), and test on 2013-2014 inclusive (2 years). But at this point we accept the default parameters for the respective algorithms and we essentially are looking at two independent time periods. In the future we will want to optimize the paramaters on the train set.",
"_____no_output_____"
]
],
[
[
"# load data from Yahoo\n# Be careful if you cange the order or types of ETFs to also change the CRP weight %'s in the swensen_allocation\netfs = ['VTI', 'EFA', 'EEM', 'TLT', 'TIP', 'VNQ']\n#etfs = ['SCHX','VOO','FNDX','PRF','SCHA','VB','FNDA','PRFZ','SCHF','VEA',\n# 'FNDF','PXF','SCHC','VSS','FNDC','PDN','SCHE','IEMG','FNDE',\n# 'PXH','SCHH','VNQ','VNQI','IFGL','SCHD','VYM','DWX','IQDF','MLPA',\n# 'ZMLP','SCHR','VGIT','ITR','VCIT','VMBS','MBG','SCHP','STIP','SHYG',\n# 'JNK','BNDX','IGOV','EMLC','VWOB','PSK','PFF','BKLN','VTEB','TFI',\n# 'PWZ','CMF','IAU','GLTR']\n# Swensen allocation from http://www.bogleheads.org/wiki/Lazy_portfolios#David_Swensen.27s_lazy_portfolio\n# as later updated here : https://www.yalealumnimagazine.com/articles/2398/david-swensen-s-guide-to-sleeping-soundly \nswensen_allocation = [0.3, 0.15, 0.1, 0.15, 0.15, 0.15] \nbenchmark = ['SPY']\ntrain_start = datetime(2008,1,1)#'2005-01-01'\ntrain_end = datetime(2012,12,31)#'2012-12-31'\ntest_start = datetime(2013,1,1)#'2013-01-01'\ntest_end = datetime(2014,12,31)#'2014-12-31'\n#train = DataReader(etfs, 'yahoo', start=train_start, end=train_end)['Adj Close']\n#test = DataReader(etfs, 'yahoo', start=test_start, end=test_end)['Adj Close']\n#train_b = DataReader(benchmark, 'yahoo', start=train_start, end=train_end)['Adj Close']\n#test_b = DataReader(benchmark, 'yahoo', start=test_start, end=test_end)['Adj Close']\ntrain = pdr.get_data_yahoo(etfs, train_start, train_end)['Adj Close']\ntest = pdr.get_data_yahoo(etfs, test_start, test_end)['Adj Close']\ntrain_b = pdr.get_data_yahoo(benchmark, train_start, train_end)['Adj Close']\ntest_b = pdr.get_data_yahoo(benchmark, test_start, test_end)['Adj Close']\n",
"_____no_output_____"
],
[
"# plot normalized prices of the train set\n#idx = pd.IndexSlice\n#ax1 = (train / train.iloc[idx[0,:]]).plot()\n#(train_b / train_b.iloc[idx[0,:]]).plot(ax=ax1)\n(train / train.iloc[0,:]).plot()",
"_____no_output_____"
],
[
"# plot normalized prices of the test set\n#ax2 = (test / test.iloc[0,:]).plot()\n#(test_b / test_b.iloc[0,:]).plot(ax=ax2)\n(test / test.iloc[0,:]).plot()",
"_____no_output_____"
]
],
[
[
"# Comparing the Algorithms",
"_____no_output_____"
],
[
"We want to train on market data from a number of years, and test out of sample for a duration smaller than the train set. To get started we accept the default parameters for the respective algorithms and we essentially are just looking at two independent time periods. In the future we will want to optimize the paramaters on the train set.",
"_____no_output_____"
]
],
[
[
"#list all the algos\nolps_algos = [\nalgos.Anticor(),\nalgos.BAH(),\nalgos.BCRP(),\nalgos.BNN(),\nalgos.CORN(),\nalgos.CRP(b=swensen_allocation), # Non Uniform CRP (the Swensen allocation)\nalgos.CWMR(),\nalgos.EG(),\nalgos.Kelly(),\nalgos.OLMAR(),\nalgos.ONS(),\nalgos.PAMR(),\nalgos.RMR(),\nalgos.UP()\n]",
"_____no_output_____"
],
[
"# put all the algos in a dataframe\nalgo_names = [a.__class__.__name__ for a in olps_algos]\nalgo_data = ['algo', 'results', 'profit', 'sharpe', 'information', 'annualized_return', 'drawdown_period','winning_pct']\nmetrics = algo_data[2:]\nolps_train = pd.DataFrame(index=algo_names, columns=algo_data)\nolps_train.algo = olps_algos",
"_____no_output_____"
]
],
[
[
"At this point we could train all the algos to find the best parameters for each.",
"_____no_output_____"
]
],
[
[
"# run all algos - this takes more than a minute\nfor name, alg in zip(olps_train.index, olps_train.algo):\n olps_train.loc[name,'results'] = alg.run(train)",
"_____no_output_____"
],
[
"# Let's make sure the fees are set to 0 at first\nfor k, r in olps_train.results.iteritems():\n r.fee = 0.0",
"_____no_output_____"
],
[
"import cycler\nn_lines = 14\ncolor_idx = np.linspace(0, 1, n_lines)\nmpl.rcParams['axes.prop_cycle']=cycler.cycler(color=[plt.cm.rainbow(i) for i in color_idx])\n# plot as if we had no fees\n# get the first result so we can grab the figure axes from the plot\n#ax = olps_train.results[0].plot(assets=False, weights=False, ucrp=True, portfolio_label=olps_train.index[0])\n#for k, r in olps_train.results.iteritems():\n #if k == olps_train.results.keys()[0]: # skip the first item because we have it already\n #continue\n #r.plot(assets=False, weights=False, ucrp=False, portfolio_label=k, ax=ax[0])\n#ax = olps_train.results[0].plot(assets=False, weights=False, ucrp=True, portfolio_label=olps_train.index[0], color='red')\nfor k, r in olps_train.results.iteritems():\n #if k == olps_train.results.keys()[0]: # skip the first item because we have it already\n #continue\n r.plot(assets=False, weights=False, ucrp=True, portfolio_label=k, color='red')",
"_____no_output_____"
],
[
"def olps_stats(df):\n for name, r in df.results.iteritems():\n df.ix[name,'profit'] = r.profit_factor\n df.ix[name,'sharpe'] = r.sharpe\n df.ix[name,'information'] = r.information\n df.ix[name,'annualized_return'] = r.annualized_return * 100\n df.ix[name,'drawdown_period'] = r.drawdown_period\n df.ix[name,'winning_pct'] = r.winning_pct * 100\n return df",
"_____no_output_____"
],
[
"olps_stats(olps_train)\nolps_train[metrics].sort_values('profit', ascending=False)",
"_____no_output_____"
],
[
"# Let's add fees of 0.1% per transaction (we pay $1 for every $1000 of stocks bought or sold).\nfor k, r in olps_train.results.iteritems():\n r.fee = 0.001",
"_____no_output_____"
],
[
"# plot with fees\n# get the first result so we can grab the figure axes from the plot\nimport plotly.plotly as py\nimport plotly.graph_objs as go\nax = olps_train.results[0].plot(assets=False, weights=False, ucrp=True, portfolio_label=olps_train.index[0])\nfor k, r in olps_train.results.iteritems():\n if k == olps_train.results.keys()[0]: # skip the first item because we have it already\n continue\n r.plot(assets=False, weights=False, ucrp=False, portfolio_label=k, ax=ax[0])",
"_____no_output_____"
]
],
[
[
"### Notice how Kelly crashes right away and how RMR and OLMAR float to the top after some high volatility. ",
"_____no_output_____"
]
],
[
[
"olps_stats(olps_train)\nolps_train[metrics].sort_values('profit', ascending=False)",
"_____no_output_____"
]
],
[
[
"# Run on the Test Set",
"_____no_output_____"
]
],
[
[
"# create the test set dataframe\nolps_test = pd.DataFrame(index=algo_names, columns=algo_data)\nolps_test.algo = olps_algos",
"_____no_output_____"
],
[
"# run all algos\nfor name, alg in zip(olps_test.index, olps_test.algo):\n olps_test.ix[name,'results'] = alg.run(test)",
"_____no_output_____"
],
[
"# Let's make sure the fees are 0 at first\nfor k, r in olps_test.results.iteritems():\n r.fee = 0.0",
"_____no_output_____"
],
[
"# plot as if we had no fees\n# get the first result so we can grab the figure axes from the plot\nax = olps_test.results[0].plot(assets=False, weights=False, ucrp=True, portfolio_label=olps_test.index[0])\nfor k, r in olps_test.results.iteritems():\n if k == olps_test.results.keys()[0]: # skip the first item because we have it already\n continue\n r.plot(assets=False, weights=False, ucrp=False, portfolio_label=k, ax=ax[0])",
"_____no_output_____"
]
],
[
[
"### Kelly went wild and crashed, so let's remove it from the mix",
"_____no_output_____"
]
],
[
[
"# plot as if we had no fees\n# get the first result so we can grab the figure axes from the plot\nax = olps_test.results[0].plot(assets=False, weights=False, ucrp=True, portfolio_label=olps_test.index[0])\nfor k, r in olps_test.results.iteritems():\n if k == olps_test.results.keys()[0] or k == 'Kelly': # skip the first item because we have it already\n continue\n r.plot(assets=False, weights=False, ucrp=False, portfolio_label=k, ax=ax[0])",
"_____no_output_____"
],
[
"olps_stats(olps_test)\nolps_test[metrics].sort_values('profit', ascending=False)",
"_____no_output_____"
]
],
[
[
"### Wow, ONS and OLMAR are at the bottom of the list. Remember, we really didn't do any training, but if we had selected ONS or OLMAR at the beginning of 2013 based on past performance, we would not have beat BAH. Hm.",
"_____no_output_____"
],
[
"# Focusing on OLMAR",
"_____no_output_____"
],
[
"Instead of using the default parameters, we will test several `window` parameters to see if we can get OLMAR to improve.",
"_____no_output_____"
]
],
[
[
"# we need need fewer colors so let's reset the colors_cycle\nmpl.rcParams['axes.prop_cycle']= default_color_cycle",
"_____no_output_____"
],
[
"train_olmar = algos.OLMAR.run_combination(train, window=[3,5,10,15], eps=10)\ntrain_olmar.plot()",
"_____no_output_____"
],
[
"print(train_olmar.summary())",
"_____no_output_____"
],
[
"train_olmar = algos.OLMAR.run_combination(train, window=5, eps=[3,5,10,15])\ntrain_olmar.plot()",
"_____no_output_____"
],
[
"print(train_olmar.summary())",
"_____no_output_____"
]
],
[
[
"### We find that a window of 5 and eps are 5 are optimal over the train time period, but the default of w=5 and eps=10 were also fine for our purposes.",
"_____no_output_____"
]
],
[
[
"# OLMAR vs UCRP\nbest_olmar = train_olmar[1]\nax1 = best_olmar.plot(ucrp=True, bah=True, weights=False, assets=False, portfolio_label='OLMAR')\nolps_train.loc['CRP'].results.plot(ucrp=False, bah=False, weights=False, assets=False, ax=ax1[0], portfolio_label='CRP')",
"_____no_output_____"
]
],
[
[
"### On the train set OLMAR really delivers over CRP !",
"_____no_output_____"
]
],
[
[
"# let's print the stats\nprint(best_olmar.summary())",
"_____no_output_____"
]
],
[
[
"### Let's see how individual ETFs contribute to portfolio equity.",
"_____no_output_____"
]
],
[
[
"best_olmar.plot_decomposition(legend=True, logy=True)",
"_____no_output_____"
]
],
[
[
"### Let's highlight the magnitude of the highest contributing ETF by removing the log scale and looking at it directly.",
"_____no_output_____"
]
],
[
[
"best_olmar.plot_decomposition(legend=True, logy=False)",
"_____no_output_____"
]
],
[
[
"### So VNQ (Real Estate) is the big driver after the market crash of 2008, which makes sense.",
"_____no_output_____"
],
[
"### Let's look at portfolio allocations",
"_____no_output_____"
]
],
[
[
"best_olmar.plot(weights=True, assets=True, ucrp=False, logy=True, portfolio_label='OLMAR')",
"_____no_output_____"
]
],
[
[
"### VNQ is the big driver of wealth (log scale). Let's test the strategy by removing the most profitable stock and comparing Total Wealth.",
"_____no_output_____"
]
],
[
[
"# find the name of the most profitable asset\nmost_profitable = best_olmar.equity_decomposed.iloc[-1].argmax()\n\n# rerun algorithm on data without it\nresult_without = algos.OLMAR().run(train.drop([most_profitable], 1))\n\n# and print results\nprint(result_without.summary())\nresult_without.plot(weights=False, assets=False, bah=True, ucrp=True, logy=True, portfolio_label='OLMAR-VNQ')",
"_____no_output_____"
],
[
"result_without.plot_decomposition(legend=True, logy=False)",
"_____no_output_____"
]
],
[
[
"### Let's add fees of 0.1% per transaction (we pay \\$1 for every \\$1000 of stocks bought or sold).",
"_____no_output_____"
]
],
[
[
"best_olmar.fee = 0.001\nprint(best_olmar.summary())\nbest_olmar.plot(weights=False, assets=False, bah=True, ucrp=True, logy=True, portfolio_label='OLMAR')",
"_____no_output_____"
]
],
[
[
"### The results now fall, with a Sharpe Ratio below the ~0.5 market Sharpe, and an annualized return that has been cut in half due to fees. It's as if all the trading makes OLMAR underperform for the first 4 years until it can grab some volatility in 2008 to beat UCRP.",
"_____no_output_____"
],
[
"### Let's look at OLMAR in the test time frame",
"_____no_output_____"
]
],
[
[
"test_olmar = algos.OLMAR(window=5, eps=5).run(test)\n#print(train_olmar.summary())\ntest_olmar.plot(ucrp=True, bah=True, weights=False, assets=False, portfolio_label='OLMAR')",
"_____no_output_____"
]
],
[
[
"### With fees",
"_____no_output_____"
]
],
[
[
"test_olmar.fee = 0.001\nprint(test_olmar.summary())\ntest_olmar.plot(weights=False, assets=False, bah=True, ucrp=True, logy=True, portfolio_label='OLMAR')",
"_____no_output_____"
]
],
[
[
"# OLMAR Starting in 2010",
"_____no_output_____"
],
[
"The 2008-2009 recession was unique. Let's try it all again starting in 2010, with a train set from 2010-2013 inclusive, and a test set of 2014.",
"_____no_output_____"
]
],
[
[
"# set train and test time periods\ntrain_start_2010= datetime(2010,1,1)\ntrain_end_2010 = datetime(2013,12,31)\ntest_start_2010 = datetime(2014,1,1)\ntest_end_2010 = datetime(2014,12,31)",
"_____no_output_____"
],
[
"# load data from Yahoo\n#train_2010 = DataReader(etfs, 'yahoo', start=train_start_2010, end=train_end_2010)['Adj Close']\n#test_2010 = DataReader(etfs, 'yahoo', start=test_start_2010, end=test_end_2010)['Adj Close']\ntrain_2010 = pdr.get_data_yahoo(etfs, train_start_2010, train_end_2010)['Adj Close']\ntest_2010 = pdr.get_data_yahoo(etfs, train_start_2010, train_end_2010)['Adj Close']",
"_____no_output_____"
],
[
"# plot normalized prices of these stocks\n(train_2010 / train_2010.iloc[0,:]).plot()",
"_____no_output_____"
],
[
"# plot normalized prices of these stocks\n(test_2010 / test_2010.iloc[0,:]).plot()",
"_____no_output_____"
],
[
"train_olmar_2010 = algos.OLMAR().run(train_2010)\ntrain_crp_2010 = algos.CRP(b=swensen_allocation).run(train_2010)\nax1 = train_olmar_2010.plot(assets=True, weights=False, ucrp=True, bah=True, portfolio_label='OLMAR')\ntrain_crp_2010.plot(ucrp=False, bah=False, weights=False, assets=False, ax=ax1[0], portfolio_label='CRP')",
"_____no_output_____"
],
[
"print(train_olmar_2010.summary())",
"_____no_output_____"
],
[
"train_olmar_2010.plot_decomposition(legend=True, logy=True)",
"_____no_output_____"
]
],
[
[
"Not bad, with a Sharpe at 1 and no one ETF dominating the portfolio. Now let's see how it fairs in 2014. ",
"_____no_output_____"
]
],
[
[
"test_olmar_2010 = algos.OLMAR().run(test_2010)\ntest_crp_2010 = algos.CRP(b=swensen_allocation).run(test_2010)\nax1 = test_olmar_2010.plot(assets=True, weights=False, ucrp=True, bah=True, portfolio_label='OLMAR')\ntest_crp_2010.plot(ucrp=False, bah=False, weights=False, assets=False, ax=ax1[0], portfolio_label='CRP')",
"_____no_output_____"
],
[
"print(test_olmar_2010.summary())",
"_____no_output_____"
]
],
[
[
"We just happen to be looking at a different time period and now the Sharpe drops below 0.5 and OLMAR fails to beat BAH. Not good.",
"_____no_output_____"
]
],
[
[
"test_olmar_2010.plot_decomposition(legend=True, logy=True)",
"_____no_output_____"
]
],
[
[
"# SPY / TLT portfolio comparison",
"_____no_output_____"
],
[
"Let's step back and simplify this by looking at OLMAR on a SPY and TLT portfolio. We should also compare this portfolio to a rebalanced 70/30 mix of SPY and TLT.",
"_____no_output_____"
]
],
[
[
"# load data from Yahoo\n#spy_tlt_data = DataReader(['SPY', 'TLT'], 'yahoo', start=datetime(2010,1,1))['Adj Close']\nspy_tlt_data = pdr.get_data_yahoo(['SPY', 'TLT'], datetime(2010,1,1))['Adj Close']\n\n# plot normalized prices of these stocks\n(spy_tlt_data / spy_tlt_data.iloc[0,:]).plot()",
"_____no_output_____"
],
[
"import plotly.plotly as py\nimport plotly.graph_objs as go\n\nimport pandas as pd\n\nTLT = pd.read_csv(\"stock_datas/TLT.csv\")\nSPY = pd.read_csv(\"stock_datas/SPY.csv\")\ndf = pd.concat([TLT,SPY.rename(columns={'date':'datex'})], ignore_index=True)\n\ntrace_spy = go.Scatter(\n x=df.Date,\n y=df['SPY.Adjusted'],\n name = \"SPY Adjusted\",\n line = dict(color = '#17BECF'),\n opacity = 0.8)\n\ntrace_tlt = go.Scatter(\n x=df.Date,\n y=df['TLT.Adjusted'],\n name = \"TLT Adjusted\",\n line = dict(color = '#7F7F7F'),\n opacity = 0.8)\n\ndata = [trace_spy,trace_tlt]\n\nlayout = dict(\n title = \"SPY / TLT portfolio comparison\",\n xaxis = dict(\n range = ['2010-01-01','2017-07-17'])\n)\n\nfig = dict(data=data, layout=layout)\n\npy.iplot(fig)",
"_____no_output_____"
],
[
"spy_tlt_olmar_2010 = algos.OLMAR().run(spy_tlt_data)\nspy_tlt_olmar_2010.plot(assets=True, weights=True, ucrp=True, bah=True, portfolio_label='OLMAR')",
"_____no_output_____"
],
[
"spy_tlt_olmar_2010.plot_decomposition(legend=True, logy=True)",
"_____no_output_____"
],
[
"print(spy_tlt_olmar_2010.summary())",
"_____no_output_____"
],
[
"spy_tlt_2010 = algos.CRP(b=[0.7, 0.3]).run(spy_tlt_data)\n\nax1 = spy_tlt_olmar_2010.plot(assets=False, weights=False, ucrp=True, bah=True, portfolio_label='OLMAR')\nspy_tlt_2010.plot(assets=False, weights=False, ucrp=False, bah=False, portfolio_label='CRP', ax=ax1[0])",
"_____no_output_____"
]
],
[
[
"## Now OLMAR looks better!",
"_____no_output_____"
],
[
"# OLMAR Market Sectors comparison",
"_____no_output_____"
],
[
"Let's look at algo behavior on market sectors:\n\n- XLY Consumer Discrectionary SPDR Fund \n- XLF Financial SPDR Fund \n- XLK Technology SPDR Fund \n- XLE Energy SPDR Fund \n- XLV Health Care SPRD Fund \n- XLI Industrial SPDR Fund \n- XLP Consumer Staples SPDR Fund \n- XLB Materials SPDR Fund \n- XLU Utilities SPRD Fund ",
"_____no_output_____"
]
],
[
[
"sectors = ['XLY','XLF','XLK','XLE','XLV','XLI','XLP','XLB','XLU']\n#train_sectors = DataReader(sectors, 'yahoo', start=train_start_2010, end=train_end_2010)['Adj Close']\n#test_sectors = DataReader(sectors, 'yahoo', start=test_start_2010, end=test_end_2010)['Adj Close']\ntrain_sectors = pdr.get_data_yahoo(sectors, train_start_2010, train_end_2010)['Adj Close']\ntest_sectors = pdr.get_data_yahoo(sectors, test_start_2010, test_end_2010)['Adj Close']",
"_____no_output_____"
],
[
"# plot normalized prices of these stocks\n(train_sectors / train_sectors.iloc[0,:]).plot()",
"_____no_output_____"
],
[
"# plot normalized prices of these stocks\n(test_sectors / test_sectors.iloc[0,:]).plot()",
"_____no_output_____"
],
[
"train_olmar_sectors = algos.OLMAR().run(train_sectors)\ntrain_olmar_sectors.plot(assets=True, weights=False, ucrp=True, bah=True, portfolio_label='OLMAR')",
"_____no_output_____"
],
[
"print(train_olmar_sectors.summary())",
"_____no_output_____"
],
[
"train_olmar_sectors.plot(assets=False, weights=False, ucrp=True, bah=True, portfolio_label='OLMAR')",
"_____no_output_____"
],
[
"test_olmar_sectors = algos.OLMAR().run(test_sectors)\ntest_olmar_sectors.plot(assets=True, weights=False, ucrp=True, bah=True, portfolio_label='OLMAR')",
"_____no_output_____"
],
[
"test_olmar_sectors = algos.OLMAR().run(test_sectors)\ntest_olmar_sectors.plot(assets=False, weights=False, ucrp=True, bah=True, portfolio_label='OLMAR')",
"_____no_output_____"
]
],
[
[
"# All OLPS Algos Market Sectors comparison",
"_____no_output_____"
]
],
[
[
"#list all the algos\nolps_algos_sectors = [\nalgos.Anticor(),\nalgos.BAH(),\nalgos.BCRP(),\nalgos.BNN(),\nalgos.CORN(),\nalgos.CRP(), # removed weights, and thus equivalent to UCRP\nalgos.CWMR(),\nalgos.EG(),\nalgos.Kelly(),\nalgos.OLMAR(),\nalgos.ONS(),\nalgos.PAMR(),\nalgos.RMR(),\nalgos.UP()\n]",
"_____no_output_____"
],
[
"olps_sectors_train = pd.DataFrame(index=algo_names, columns=algo_data)\nolps_sectors_train.algo = olps_algos_sectors",
"_____no_output_____"
],
[
"# run all algos - this takes more than a minute\nfor name, alg in zip(olps_sectors_train.index, olps_sectors_train.algo):\n olps_sectors_train.ix[name,'results'] = alg.run(train_sectors)",
"_____no_output_____"
],
[
"# we need 14 colors for the plot\nn_lines = 14\ncolor_idx = np.linspace(0, 1, n_lines)\nmpl.rcParams['axes.color_cycle']=[plt.cm.rainbow(i) for i in color_idx]",
"_____no_output_____"
],
[
"# plot as if we had no fees\n# get the first result so we can grab the figure axes from the plot\nolps_df = olps_sectors_train\nax = olps_df.results[0].plot(assets=False, weights=False, ucrp=True, portfolio_label=olps_df.index[0])\nfor k, r in olps_df.results.iteritems():\n if k == olps_df.results.keys()[0]: # skip the first item because we have it already\n continue\n r.plot(assets=False, weights=False, ucrp=False, portfolio_label=k, ax=ax[0])",
"_____no_output_____"
],
[
"# Kelly went wild, so let's remove it\n# get the first result so we can grab the figure axes from the plot\nolps_df = olps_sectors_train\nax = olps_df.results[0].plot(assets=False, weights=False, ucrp=True, portfolio_label=olps_df.index[0])\nfor k, r in olps_df.results.iteritems():\n if k == olps_df.results.keys()[0] or k == 'Kelly' : # skip the first item because we have it already\n continue\n r.plot(assets=False, weights=False, ucrp=False, portfolio_label=k, ax=ax[0])",
"_____no_output_____"
],
[
"olps_stats(olps_sectors_train)\nolps_sectors_train[metrics].sort_values('profit', ascending=False)",
"_____no_output_____"
],
[
"# create the test set dataframe\nolps_sectors_test = pd.DataFrame(index=algo_names, columns=algo_data)\nolps_sectors_test.algo = olps_algos_sectors",
"_____no_output_____"
],
[
"# run all algos\nfor name, alg in zip(olps_sectors_test.index, olps_sectors_test.algo):\n olps_sectors_test.ix[name,'results'] = alg.run(test_sectors)",
"_____no_output_____"
],
[
"# plot as if we had no fees\n# get the first result so we can grab the figure axes from the plot\nolps_df = olps_sectors_test\nax = olps_df.results[0].plot(assets=False, weights=False, ucrp=True, portfolio_label=olps_df.index[0])\nfor k, r in olps_df.results.iteritems():\n if k == olps_df.results.keys()[0] : #or k == 'Kelly': # skip the first item because we have it already\n continue\n r.plot(assets=False, weights=False, ucrp=False, portfolio_label=k, ax=ax[0])",
"_____no_output_____"
],
[
"# drop Kelly !\n# get the first result so we can grab the figure axes from the plot\nolps_df = olps_sectors_test\nax = olps_df.results[0].plot(assets=False, weights=False, ucrp=True, portfolio_label=olps_df.index[0])\nfor k, r in olps_df.results.iteritems():\n if k == olps_df.results.keys()[0] or k == 'Kelly': # skip the first item because we have it already\n continue\n r.plot(assets=False, weights=False, ucrp=False, portfolio_label=k, ax=ax[0])",
"_____no_output_____"
],
[
"olps_stats(olps_sectors_test)\nolps_sectors_test[metrics].sort_values('profit', ascending=False)",
"_____no_output_____"
]
],
[
[
"# Further work",
"_____no_output_____"
],
[
"- More algo's could be optimized for parameters before they are run against the test set\n- In addition to the BAH, CRP and BCRP benchmarks, we could consider holding [SPY](https://www.google.com/finance?q=SPY) at 100% as a benchmark.\n- Could look into BAH(OLMAR) and other combinations as this framework supports combining approaches directly\n- Experiment with the ```run_subsets``` feature",
"_____no_output_____"
],
[
"# Conclusion",
"_____no_output_____"
],
[
"RMR and OLMAR do add value to a Lazy Portfolio if tested or run over a long enough period of time. This gives RMR and OLMAR a chance to grab onto a period of volatility. But in an up market (2013-1014) you want to Follow-the-Leader, not Follow-the-Looser. Of the other algo's, CRP or BAH are decent, and maybe it's worth understanding what ONS is doing.",
"_____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"
] | [
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
]
] |
ecea20decb8ca0307e3ca0e098b290b308eaca9b | 21,945 | ipynb | Jupyter Notebook | courses/machine_learning/deepdive/06_structured/labs/5_train.ipynb | Glairly/introduction_to_tensorflow | aa0a44d9c428a6eb86d1f79d73f54c0861b6358d | [
"Apache-2.0"
] | 2 | 2022-01-06T11:52:57.000Z | 2022-01-09T01:53:56.000Z | courses/machine_learning/deepdive/06_structured/labs/5_train.ipynb | Glairly/introduction_to_tensorflow | aa0a44d9c428a6eb86d1f79d73f54c0861b6358d | [
"Apache-2.0"
] | null | null | null | courses/machine_learning/deepdive/06_structured/labs/5_train.ipynb | Glairly/introduction_to_tensorflow | aa0a44d9c428a6eb86d1f79d73f54c0861b6358d | [
"Apache-2.0"
] | null | null | null | 38.165217 | 554 | 0.547368 | [
[
[
"<h1>Training on Cloud AI Platform</h1>\n\nThis notebook illustrates distributed training on Cloud AI Platform (formerly known as Cloud ML Engine).",
"_____no_output_____"
]
],
[
[
"!sudo chown -R jupyter:jupyter /home/jupyter/training-data-analyst",
"_____no_output_____"
],
[
"# Ensure the right version of Tensorflow is installed.\n!pip freeze | grep tensorflow==2.1",
"_____no_output_____"
],
[
"# change these to try this notebook out\nBUCKET = 'cloud-training-demos-ml'\nPROJECT = 'cloud-training-demos'\nREGION = 'us-central1'",
"_____no_output_____"
],
[
"import os\nos.environ['BUCKET'] = BUCKET\nos.environ['PROJECT'] = PROJECT\nos.environ['REGION'] = REGION\nos.environ['TFVERSION'] = '2.1'",
"_____no_output_____"
],
[
"%%bash\ngcloud config set project $PROJECT\ngcloud config set compute/region $REGION",
"_____no_output_____"
],
[
"%%bash\nif ! gsutil ls | grep -q gs://${BUCKET}/babyweight/preproc; then\n gsutil mb -l ${REGION} gs://${BUCKET}\n # copy canonical set of preprocessed files if you didn't do previous notebook\n gsutil -m cp -R gs://cloud-training-demos/babyweight gs://${BUCKET}\nfi",
"_____no_output_____"
],
[
"%%bash\ngsutil ls gs://${BUCKET}/babyweight/preproc/*-00000*",
"_____no_output_____"
]
],
[
[
"Now that we have the TensorFlow code working on a subset of the data, we can package the TensorFlow code up as a Python module and train it on Cloud AI Platform.\n<p>\n<h2> Train on Cloud AI Platform</h2>\n<p>\nTraining on Cloud AI Platform requires:\n<ol>\n<li> Making the code a Python package\n<li> Using gcloud to submit the training code to Cloud AI Platform\n</ol>\n\nEnsure that the AI Platform API is enabled by going to this [link](https://console.developers.google.com/apis/library/ml.googleapis.com).",
"_____no_output_____"
],
[
"## Lab Task 1\n\nThe following code edits babyweight/trainer/task.py. You should use add hyperparameters needed by your model through the command-line using the `parser` module. Look at how `batch_size` is passed to the model in the code below. Do this for the following hyperparameters (defaults in parentheses): `train_examples` (5000), `eval_steps` (None), `pattern` (of).",
"_____no_output_____"
]
],
[
[
"%%writefile babyweight/trainer/task.py\nimport argparse\nimport json\nimport os\n\nfrom . import model\n\nimport tensorflow.compat.v1 as tf\ntf.disable_v2_behavior()\n\nif __name__ == '__main__':\n parser = argparse.ArgumentParser()\n parser.add_argument(\n '--bucket',\n help = 'GCS path to data. We assume that data is in gs://BUCKET/babyweight/preproc/',\n required = True\n )\n parser.add_argument(\n '--output_dir',\n help = 'GCS location to write checkpoints and export models',\n required = True\n )\n parser.add_argument(\n '--batch_size',\n help = 'Number of examples to compute gradient over.',\n type = int,\n default = 512\n )\n parser.add_argument(\n '--job-dir',\n help = 'this model ignores this field, but it is required by gcloud',\n default = 'junk'\n )\n parser.add_argument(\n '--nnsize',\n help = 'Hidden layer sizes to use for DNN feature columns -- provide space-separated layers',\n nargs = '+',\n type = int,\n default=[128, 32, 4]\n )\n parser.add_argument(\n '--nembeds',\n help = 'Embedding size of a cross of n key real-valued parameters',\n type = int,\n default = 3\n )\n\n ## TODOs after this line\n ################################################################################\n \n ## TODO 1: add the new arguments here \n\n ## parse all arguments\n args = parser.parse_args()\n arguments = args.__dict__\n\n # unused args provided by service\n arguments.pop('job_dir', None)\n arguments.pop('job-dir', None)\n\n ## assign the arguments to the model variables\n output_dir = arguments.pop('output_dir')\n model.BUCKET = arguments.pop('bucket')\n model.BATCH_SIZE = arguments.pop('batch_size')\n model.TRAIN_STEPS = (arguments.pop('train_examples') * 100) / model.BATCH_SIZE\n model.EVAL_STEPS = arguments.pop('eval_steps') \n print (\"Will train for {} steps using batch_size={}\".format(model.TRAIN_STEPS, model.BATCH_SIZE))\n model.PATTERN = arguments.pop('pattern')\n model.NEMBEDS= arguments.pop('nembeds')\n model.NNSIZE = arguments.pop('nnsize')\n print (\"Will use DNN size of {}\".format(model.NNSIZE))\n\n # Append trial_id to path if we are doing hptuning\n # This code can be removed if you are not using hyperparameter tuning\n output_dir = os.path.join(\n output_dir,\n json.loads(\n os.environ.get('TF_CONFIG', '{}')\n ).get('task', {}).get('trial', '')\n )\n\n # Run the training job\n model.train_and_evaluate(output_dir)",
"_____no_output_____"
]
],
[
[
"## Lab Task 2\n\nAddress all the TODOs in the following code in `babyweight/trainer/model.py` with the cell below. This code is similar to the model training code we wrote in Lab 3. \n\nAfter addressing all TODOs, run the cell to write the code to the model.py file.",
"_____no_output_____"
]
],
[
[
"%%writefile babyweight/trainer/model.py\nimport shutil\nimport numpy as np\n\nimport tensorflow.compat.v1 as tf\ntf.disable_v2_behavior()\n\ntf.logging.set_verbosity(tf.logging.INFO)\n\nBUCKET = None # set from task.py\nPATTERN = 'of' # gets all files\n\n# Determine CSV, label, and key columns\nCSV_COLUMNS = 'weight_pounds,is_male,mother_age,plurality,gestation_weeks,key'.split(',')\nLABEL_COLUMN = 'weight_pounds'\nKEY_COLUMN = 'key'\n\n# Set default values for each CSV column\nDEFAULTS = [[0.0], ['null'], [0.0], ['null'], [0.0], ['nokey']]\n\n# Define some hyperparameters\nTRAIN_STEPS = 10000\nEVAL_STEPS = None\nBATCH_SIZE = 512\nNEMBEDS = 3\nNNSIZE = [64, 16, 4]\n\n# Create an input function reading a file using the Dataset API\n# Then provide the results to the Estimator API\ndef read_dataset(prefix, mode, batch_size):\n def _input_fn():\n def decode_csv(value_column):\n columns = tf.decode_csv(value_column, record_defaults=DEFAULTS)\n features = dict(zip(CSV_COLUMNS, columns))\n label = features.pop(LABEL_COLUMN)\n return features, label\n \n # Use prefix to create file path\n file_path = 'gs://{}/babyweight/preproc/{}*{}*'.format(BUCKET, prefix, PATTERN)\n\n # Create list of files that match pattern\n file_list = tf.gfile.Glob(file_path)\n\n # Create dataset from file list\n dataset = (tf.data.TextLineDataset(file_list) # Read text file\n .map(decode_csv)) # Transform each elem by applying decode_csv fn\n \n if mode == tf.estimator.ModeKeys.TRAIN:\n num_epochs = None # indefinitely\n dataset = dataset.shuffle(buffer_size = 10 * batch_size)\n else:\n num_epochs = 1 # end-of-input after this\n \n dataset = dataset.repeat(num_epochs).batch(batch_size)\n return dataset.make_one_shot_iterator().get_next()\n return _input_fn\n\n# Define feature columns\ndef get_wide_deep():\n # Define column types\n is_male,mother_age,plurality,gestation_weeks = \\\n [\\\n tf.feature_column.categorical_column_with_vocabulary_list('is_male', \n ['True', 'False', 'Unknown']),\n tf.feature_column.numeric_column('mother_age'),\n tf.feature_column.categorical_column_with_vocabulary_list('plurality',\n ['Single(1)', 'Twins(2)', 'Triplets(3)',\n 'Quadruplets(4)', 'Quintuplets(5)','Multiple(2+)']),\n tf.feature_column.numeric_column('gestation_weeks')\n ]\n\n # Discretize\n age_buckets = tf.feature_column.bucketized_column(mother_age, \n boundaries=np.arange(15,45,1).tolist())\n gestation_buckets = tf.feature_column.bucketized_column(gestation_weeks, \n boundaries=np.arange(17,47,1).tolist())\n \n # Sparse columns are wide, have a linear relationship with the output\n wide = [is_male,\n plurality,\n age_buckets,\n gestation_buckets]\n \n # Feature cross all the wide columns and embed into a lower dimension\n crossed = tf.feature_column.crossed_column(wide, hash_bucket_size=20000)\n embed = tf.feature_column.embedding_column(crossed, NEMBEDS)\n \n # Continuous columns are deep, have a complex relationship with the output\n deep = [mother_age,\n gestation_weeks,\n embed]\n return wide, deep\n\n# Create serving input function to be able to serve predictions later using provided inputs\ndef serving_input_fn():\n feature_placeholders = {\n 'is_male': tf.placeholder(tf.string, [None]),\n 'mother_age': tf.placeholder(tf.float32, [None]),\n 'plurality': tf.placeholder(tf.string, [None]),\n 'gestation_weeks': tf.placeholder(tf.float32, [None]),\n KEY_COLUMN: tf.placeholder_with_default(tf.constant(['nokey']), [None])\n }\n features = {\n key: tf.expand_dims(tensor, -1)\n for key, tensor in feature_placeholders.items()\n }\n return tf.estimator.export.ServingInputReceiver(features, feature_placeholders)\n\n# create metric for hyperparameter tuning\ndef my_rmse(labels, predictions):\n pred_values = predictions['predictions']\n return {'rmse': tf.metrics.root_mean_squared_error(labels, pred_values)}\n\ndef forward_features(estimator, key):\n def new_model_fn(features, labels, mode, config):\n spec = estimator.model_fn(features, labels, mode, config)\n predictions = spec.predictions\n predictions[key] = features[key]\n spec = spec._replace(predictions=predictions)\n return spec\n return tf.estimator.Estimator(model_fn=new_model_fn, model_dir=estimator.model_dir, config=estimator.config)\n\n## TODOs after this line\n################################################################################\n\n# Create estimator to train and evaluate\ndef train_and_evaluate(output_dir):\n tf.summary.FileWriterCache.clear() # ensure filewriter cache is clear for TensorBoard events file\n wide, deep = get_wide_deep()\n EVAL_INTERVAL = 300 # seconds\n\n ## TODO 2a: set the save_checkpoints_secs to the EVAL_INTERVAL\n run_config = tf.estimator.RunConfig(save_checkpoints_secs = None,\n keep_checkpoint_max = 3)\n \n ## TODO 2b: change the dnn_hidden_units to NNSIZE\n estimator = tf.estimator.DNNLinearCombinedRegressor(\n model_dir = output_dir,\n linear_feature_columns = wide,\n dnn_feature_columns = deep,\n dnn_hidden_units = None,\n config = run_config)\n \n # illustrates how to add an extra metric\n estimator = tf.estimator.add_metrics(estimator, my_rmse)\n # for batch prediction, you need a key associated with each instance\n estimator = forward_features(estimator, KEY_COLUMN)\n\n ## TODO 2c: Set the third argument of read_dataset to BATCH_SIZE \n ## TODO 2d: and set max_steps to TRAIN_STEPS\n train_spec = tf.estimator.TrainSpec(\n input_fn = read_dataset('train', tf.estimator.ModeKeys.TRAIN, None),\n max_steps = None)\n \n exporter = tf.estimator.LatestExporter('exporter', serving_input_fn, exports_to_keep=None)\n\n ## TODO 2e: Lastly, set steps equal to EVAL_STEPS\n eval_spec = tf.estimator.EvalSpec(\n input_fn = read_dataset('eval', tf.estimator.ModeKeys.EVAL, 2**15), # no need to batch in eval\n steps = None,\n start_delay_secs = 60, # start evaluating after N seconds\n throttle_secs = EVAL_INTERVAL, # evaluate every N seconds\n exporters = exporter)\n tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)",
"_____no_output_____"
]
],
[
[
"## Lab Task 3\n\nAfter moving the code to a package, make sure it works standalone. (Note the --pattern and --train_examples lines so that I am not trying to boil the ocean on the small notebook VM. Change as appropriate for your model).\n<p>\nEven with smaller data, this might take <b>3-5 minutes</b> in which you won't see any output ...",
"_____no_output_____"
]
],
[
[
"%%bash\necho \"bucket=${BUCKET}\"\nrm -rf babyweight_trained\nexport PYTHONPATH=${PYTHONPATH}:${PWD}/babyweight\npython -m trainer.task \\\n --bucket=${BUCKET} \\\n --output_dir=babyweight_trained \\\n --job-dir=./tmp \\\n --pattern=\"00000-of-\" --train_examples=1 --eval_steps=1",
"_____no_output_____"
]
],
[
[
"## Lab Task 4\n\nThe JSON below represents an input into your prediction model. Write the input.json file below with the next cell, then run the prediction locally to assess whether it produces predictions correctly.",
"_____no_output_____"
]
],
[
[
"%%writefile inputs.json\n{\"key\": \"b1\", \"is_male\": \"True\", \"mother_age\": 26.0, \"plurality\": \"Single(1)\", \"gestation_weeks\": 39}\n{\"key\": \"g1\", \"is_male\": \"False\", \"mother_age\": 26.0, \"plurality\": \"Single(1)\", \"gestation_weeks\": 39}",
"_____no_output_____"
],
[
"%%bash\nsudo find \"/usr/lib/google-cloud-sdk/lib/googlecloudsdk/command_lib/ml_engine\" -name '*.pyc' -delete",
"_____no_output_____"
],
[
"%%bash\nMODEL_LOCATION=$(ls -d $(pwd)/babyweight_trained/export/exporter/* | tail -1)\necho $MODEL_LOCATION\ngcloud ai-platform local predict --model-dir=$MODEL_LOCATION --json-instances=inputs.json",
"_____no_output_____"
]
],
[
[
"## Lab Task 5\n\nOnce the code works in standalone mode, you can run it on Cloud AI Platform. \nChange the parameters to the model (-train_examples for example may not be part of your model) appropriately.\n\nBecause this is on the entire dataset, it will take a while. The training run took about <b> 2 hours </b> for me. You can monitor the job from the GCP console in the Cloud AI Platform section.",
"_____no_output_____"
]
],
[
[
"%%bash\nOUTDIR=gs://${BUCKET}/babyweight/trained_model\nJOBNAME=babyweight_$(date -u +%y%m%d_%H%M%S)\necho $OUTDIR $REGION $JOBNAME\ngsutil -m rm -rf $OUTDIR\ngcloud ai-platform jobs submit training $JOBNAME \\\n --region=$REGION \\\n --module-name=trainer.task \\\n --package-path=$(pwd)/babyweight/trainer \\\n --job-dir=$OUTDIR \\\n --staging-bucket=gs://$BUCKET \\\n --scale-tier=STANDARD_1 \\\n --runtime-version=2.1 \\\n --python-version=3.7 \\\n -- \\\n --bucket=${BUCKET} \\\n --output_dir=${OUTDIR} \\\n --train_examples=20000",
"_____no_output_____"
]
],
[
[
"When I ran it, I used train_examples=20000. When training finished, I filtered in the Stackdriver log on the word \"dict\" and saw that the last line was:\n<pre>\nSaving dict for global step 5714290: average_loss = 1.06473, global_step = 5714290, loss = 34882.4, rmse = 1.03186\n</pre>\nThe final RMSE was 1.03 pounds.",
"_____no_output_____"
],
[
"<h2> Repeat training </h2>\n<p>\nThis time with tuned parameters (note last line)",
"_____no_output_____"
]
],
[
[
"%%bash\nOUTDIR=gs://${BUCKET}/babyweight/trained_model_tuned\nJOBNAME=babyweight_$(date -u +%y%m%d_%H%M%S)\necho $OUTDIR $REGION $JOBNAME\ngsutil -m rm -rf $OUTDIR\ngcloud ai-platform jobs submit training $JOBNAME \\\n --region=$REGION \\\n --module-name=trainer.task \\\n --package-path=$(pwd)/babyweight/trainer \\\n --job-dir=$OUTDIR \\\n --staging-bucket=gs://$BUCKET \\\n --scale-tier=STANDARD_1 \\\n --runtime-version=2.1 \\\n --python-version=3.7 \\\n -- \\\n --bucket=${BUCKET} \\\n --output_dir=${OUTDIR} \\\n --train_examples=2000 --batch_size=35 --nembeds=16 --nnsize=281",
"_____no_output_____"
]
],
[
[
"Copyright 2017 Google Inc. Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
]
] |
ecea237a6672e9ea510bbcca0bec494cc7cb94e4 | 5,493 | ipynb | Jupyter Notebook | STRINGS.ipynb | dejanBpetrovic/pythonOsnove | d1f67c148cde85ab7813b997f273794f2fc05ddb | [
"MIT"
] | null | null | null | STRINGS.ipynb | dejanBpetrovic/pythonOsnove | d1f67c148cde85ab7813b997f273794f2fc05ddb | [
"MIT"
] | null | null | null | STRINGS.ipynb | dejanBpetrovic/pythonOsnove | d1f67c148cde85ab7813b997f273794f2fc05ddb | [
"MIT"
] | null | null | null | 18.31 | 592 | 0.458948 | [
[
[
"string = \"123XYZ+-*/\"",
"_____no_output_____"
],
[
"print (string)",
"123XYZ+-*/\n"
],
[
"String = '123xZy+-*/'",
"_____no_output_____"
],
[
"print (String)",
"123xZy+-*/\n"
],
[
"string = \"OVO JE NOVI STRING\"",
"_____no_output_____"
],
[
"print (string)",
"OVO JE NOVI STRING\n"
],
[
"#korišćenje indeksa",
"_____no_output_____"
],
[
"a = \"ABCDEFG\"[6]",
"_____no_output_____"
],
[
"b = \"ABCDEFG\"[1]",
"_____no_output_____"
],
[
"c = \"ABCDEFG\"[3]",
"_____no_output_____"
],
[
"print (b+a+c)",
"BGD\n"
],
[
"d=\"ABCDEFG\"[0:4]",
"_____no_output_____"
],
[
"print (d)",
"ABCD\n"
],
[
"#citanje unazad putem negativnog indeksa\ne =\"ABCDEFG\"[-1]",
"_____no_output_____"
],
[
"print(e)",
"G\n"
],
[
"#funkcija str()\n\ns = \"broj\"\nss= 1\nsss = (s+ss)",
"_____no_output_____"
],
[
"s = \"broj\"\nss= str(1)\nsss = str((s+ss))",
"_____no_output_____"
],
[
"print (sss)",
"broj1\n"
],
[
"# funkcija input()",
"_____no_output_____"
],
[
"s = input(\"Unesi reč BROJ \")\nss = str (1) \nsss = (s+ss)\nprint (sss)",
"Unesi reč BROJ BROJ\nBROJ1\n"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ecea2a184313df03eaa2621a54328b4071e1fa08 | 28,229 | ipynb | Jupyter Notebook | winter21/3_beatmap_features/1_beatmaps_analysis.ipynb | the-data-science-union/dsu-mlpp | fb1bd4022b20a74b90e98bc8798a8586fcf8f197 | [
"MIT"
] | null | null | null | winter21/3_beatmap_features/1_beatmaps_analysis.ipynb | the-data-science-union/dsu-mlpp | fb1bd4022b20a74b90e98bc8798a8586fcf8f197 | [
"MIT"
] | 37 | 2021-01-27T19:10:52.000Z | 2021-03-08T01:09:06.000Z | winter21/3_beatmap_features/1_beatmaps_analysis.ipynb | the-data-science-union/dsu-mlpp | fb1bd4022b20a74b90e98bc8798a8586fcf8f197 | [
"MIT"
] | 2 | 2021-03-04T02:02:40.000Z | 2021-04-21T04:55:41.000Z | 26.936069 | 1,689 | 0.53027 | [
[
[
"## Notebook Objective: Analyze the Most Popular Beatmaps and their Attributes",
"_____no_output_____"
]
],
[
[
"import sys\nsys.path.append('..')\nfrom pymongo import UpdateOne\nimport pandas as pd\nimport matplotlib.pyplot as plt\nfrom pymongo import MongoClient\nimport seaborn as sns\nfrom mlpp.data_collection.sample import ScoresSubset, get_more_recent_than",
"_____no_output_____"
],
[
"client = MongoClient('localhost', 27017, username='admin', password=\"dsumlppftw\")\ndb = client.osu_random_db\ndata = client[\"osu_random_db\"]\n\nosu_subset = ScoresSubset(data['osu_scores_high'], data['osu_user_stats'])",
"_____no_output_____"
],
[
"new_subset, user_ids = osu_subset.init_random_sample(data['sample_scores_1M'], data['sample_users_1M'], 1000)\n#creating a new collection of 1 million scores",
"_____no_output_____"
],
[
"collection = data[\"sample_scores_1M\"]\n#got 500k sample scores more recent than 12/1/2018 (last 2 years)\n#get_more_recent_than function is in the file Sample.py",
"_____no_output_____"
],
[
"collection2 = data[\"sample_scores_3k\"]",
"_____no_output_____"
],
[
"\"\"\"\nmax est user pp in collection of 500k\n\"\"\"\ncursor=db.scores_sample_3k.aggregate(\n [\n {\n \"$group\":\n {\n \"_id\": {},\n \"max\": { \"$max\": \"$mlpp.est_user_pp\" }\n }\n }\n ]\n)\nfor document in cursor:\n print(document)\nprint(document['max'])\nmax_pp = document['max']",
"{'_id': {}, 'max': 8858.10306730833}\n8858.10306730833\n"
]
],
[
[
"## Objective 1: Create a \"Uniform\" Collection ",
"_____no_output_____"
]
],
[
[
"a = 0\nb = 100\n\nwhile b <= max_pp:\n db.uniform_collection2.insert_many(\n collection2.aggregate([\n {\n '$match': {\n 'mlpp.est_user_pp' : {\n '$gt': a,\n '$lt': b,\n }\n }\n },\n {'$sample': {\n 'size': 800\n }\n}\n \n])\n )\n a = b\n b += 100\n# creates a new \"uniform\" collection",
"_____no_output_____"
]
],
[
[
"## Objective 2: Create a Collection of the 1000 Most Popular Beatmaps",
"_____no_output_____"
]
],
[
[
"#once you have a uniform collection, use this to have a collection with the most 1000 popular maps:\ndb.uniform_collection2.aggregate([\n {\n '$group': {\n '_id': '$beatmap_id', \n 'count': {\n '$sum': 1\n }\n }\n }, {\n '$sort': {\n 'count': -1\n }\n }, {\n '$limit': 1000\n }, {\n '$out': 'oneThousand_most_popular_maps2'\n }\n])",
"_____no_output_____"
]
],
[
[
"## Objective 3: Relationship as Score Count Decreases",
"_____no_output_____"
]
],
[
[
"g=[]\nh=[]\nx=db.oneThousand_most_popular_maps2\nx1=x.find({},{ \"_id\": 0, \"count\": 1}) #finds only the count column in the collection\ny1=x.find({},{ \"_id\": 1, \"count\": 0})\n\n# for i in x.find({},{ \"_id\": 0, \"count\": 1}):\n# print(i)\n\nfor i in x1:\n g.append(i['count'])\nfor i in x.find({},{ \"_id\": 1, \"count\": 0}):\n h.append(i['_id'])\n\nplt.plot(g,'ro') #automatically index x \nplt.xlabel('index')\nplt.ylabel('count')\nplt.title('Relationship as Score Count Decreases')\n\n#Score count seems to decrease exponentially",
"_____no_output_____"
]
],
[
[
"## Objective 4 & 6: Feature Distribution Analysis",
"_____no_output_____"
]
],
[
[
"collection = data[\"osu_beatmap_attribs\"]",
"_____no_output_____"
],
[
"db.osu_beatmaps_attribs_modZero.insert_many(\n collection.aggregate([\n {\n '$match': {\n 'mods': 0\n }\n }\n]))\n\n#creating a collection from the beatmap_attrib with only documents containing mod zero",
"_____no_output_____"
],
[
"collection = data['oneThousand_most_popular_maps2']",
"_____no_output_____"
],
[
"cursor = collection.find({},{\"_id\":1})\nl = []\nfor el in cursor:\n l.append(el)\nlistOfIds = []\nfor i in range(1000):\n listOfIds.append(l[i]['_id'])\n#list of id's among the 1k most popular beatmaps",
"_____no_output_____"
],
[
"collection2 = data['osu_beatmap_attribs']",
"_____no_output_____"
],
[
"for _id in listOfIds:\n db.oneThousand_Beatmaps_attribs.insert_many(\n collection2.aggregate([\n {'$match' : {\n \"_id\" : _id }\n }\n ] ))\n#from the beatmap attrib collection, creating a new collection with beatmap attrib for the 1k most popular maps",
"_____no_output_____"
],
[
"collection = data[\"osu_beatmaps_attribs_modZero\"]",
"_____no_output_____"
]
],
[
[
"Distribution for attribute 5",
"_____no_output_____"
]
],
[
[
"db.attrib_5.insert_many(\n collection.aggregate([\n {'$match':{\n \"beatmap_id\": {\n '$in': listOfIds\n },\n \"attrib_id\": 5,\n } \n }\n])\n )",
"_____no_output_____"
],
[
"c1=[]\nd=[]\nt=db.attrib_5\nx=t.find({},{ \"_id\": 1, \"count\": 0})\ny=t.find({},{ \"_id\": 0, \"value\": 1})\n\nfor i in y:\n d.append(i['value'])\nfor i in x:\n c1.append(i[\"beatmap_id\"])\n\nplt.hist(d)\nplt.show()",
"_____no_output_____"
]
],
[
[
"Distribution for attribute 17",
"_____no_output_____"
]
],
[
[
"db.attrib_17.insert_many(\n collection.aggregate([\n {'$match':{\n \"beatmap_id\": {\n '$in': listOfIds\n },\n \"attrib_id\": 17,\n } \n }\n])\n )",
"_____no_output_____"
],
[
"j=[]\nk=[]\nt=db.attrib_17\nx=t.find({},{ \"_id\": 1, \"count\": 0})\ny=t.find({},{ \"_id\": 0, \"value\": 1})\n\nfor i in y:\n k.append(i['value'])\nfor i in x:\n j.append(i[\"beatmap_id\"])\n \nk\nplt.hist(k)\nplt.show()",
"_____no_output_____"
]
],
[
[
"Distribution for attribute 1",
"_____no_output_____"
]
],
[
[
"db.attrib_1.insert_many(\n collection.aggregate([\n {'$match':{\n \"beatmap_id\": {\n '$in': listOfIds\n },\n \"attrib_id\": 1,\n } \n }\n])\n )",
"_____no_output_____"
],
[
"j=[]\nk=[]\nt=db.attrib_1\nx=t.find({},{ \"_id\": 1, \"count\": 0})\ny=t.find({},{ \"_id\": 0, \"value\": 1})\n\nfor i in y:\n k.append(i['value'])\nfor i in x:\n j.append(i[\"beatmap_id\"])\n \nk\nplt.hist(k)\nplt.show()",
"_____no_output_____"
]
],
[
[
"Distribution for attribute 3",
"_____no_output_____"
]
],
[
[
"db.attrib_3.insert_many(\n collection.aggregate([\n {'$match':{\n \"beatmap_id\": {\n '$in': listOfIds\n },\n \"attrib_id\": 3,\n } \n }\n])\n )",
"_____no_output_____"
],
[
"j=[]\nk=[]\nt=db.attrib_3\nx=t.find({},{ \"_id\": 1, \"count\": 0})\ny=t.find({},{ \"_id\": 0, \"value\": 1})\n\nfor i in y:\n k.append(i['value'])\nfor i in x:\n j.append(i[\"beatmap_id\"])\n \nk\nplt.hist(k)\nplt.show()",
"_____no_output_____"
]
],
[
[
"Distribution for Attribute 7",
"_____no_output_____"
]
],
[
[
"db.attrib_7.insert_many(\n collection.aggregate([\n {'$match':{\n \"beatmap_id\": {\n '$in': listOfIds\n },\n \"attrib_id\": 7,\n } \n }\n])\n )",
"_____no_output_____"
],
[
"j=[]\nk=[]\nt=db.attrib_7\nx=t.find({},{ \"_id\": 1, \"count\": 0})\ny=t.find({},{ \"_id\": 0, \"value\": 1})\n\nfor i in y:\n k.append(i['value'])\nfor i in x:\n j.append(i[\"beatmap_id\"])\n \nk\nplt.hist(k)\nplt.show()",
"_____no_output_____"
]
],
[
[
"Distribution for attribute 9",
"_____no_output_____"
]
],
[
[
"db.attrib_9.insert_many(\n collection.aggregate([\n {'$match':{\n \"beatmap_id\": {\n '$in': listOfIds\n },\n \"attrib_id\": 9,\n } \n }\n])\n )",
"_____no_output_____"
],
[
"j=[]\nk=[]\nt=db.attrib_9\nx=t.find({},{ \"_id\": 1, \"count\": 0})\ny=t.find({},{ \"_id\": 0, \"value\": 1})\n\nfor i in y:\n k.append(i['value'])\nfor i in x:\n j.append(i[\"beatmap_id\"])\n \nk\nplt.hist(k)\nplt.show()",
"_____no_output_____"
]
],
[
[
"Distribution for attribute 11",
"_____no_output_____"
]
],
[
[
"db.attrib_11.insert_many(\n collection.aggregate([\n {'$match':{\n \"beatmap_id\": {\n '$in': listOfIds\n },\n \"attrib_id\": 11,\n } \n }\n])\n )",
"_____no_output_____"
],
[
"j=[]\nk=[]\nt=db.attrib_11\nx=t.find({},{ \"_id\": 1, \"count\": 0})\ny=t.find({},{ \"_id\": 0, \"value\": 1})\n\nfor i in y:\n k.append(i['value'])\nfor i in x:\n j.append(i[\"beatmap_id\"])\n \nk\nplt.hist(k)\nplt.show()",
"_____no_output_____"
]
],
[
[
"## Objective 5: Star/OD Correlation with Popularity of Beatmap",
"_____no_output_____"
]
],
[
[
"df = pd.DataFrame(list(db.oneThousand_most_popular_maps2.find({})))\ndf.sort_values([\"_id\"], inplace = True)\ndf.reset_index(inplace = True)\na = df[\"count\"]",
"_____no_output_____"
],
[
"df1 = pd.DataFrame()\ndf1[\"beatmap_id\"] = j\ndf1['Star Difficulty'] = k\ndf1[\"count\"] = a\ndf1.sort_values(by = [\"count\"], axis = 0, ascending = False, inplace = True)\nc = df1[\"count\"]\nsd = df1[\"Star Difficulty\"]\ndf1",
"_____no_output_____"
],
[
"plt.scatter(c, sd)",
"_____no_output_____"
],
[
"df2 = pd.DataFrame()\ndf2[\"beatmap_id\"] = c1\ndf2['OD'] = d\ndf2[\"count\"] = a\ndf2\n\n#recall d is the list of OD values ",
"_____no_output_____"
],
[
"c2 = df2[\"count\"]\nod = df2[\"OD\"]",
"_____no_output_____"
],
[
"plt.scatter(c2, od)",
"_____no_output_____"
]
],
[
[
"## Objective 7: Heatmap of Correlation Between Attributes",
"_____no_output_____"
]
],
[
[
"df3 = pd.DataFrame(list(db.osu_beatmaps_attribs_modZero.find({})))\ndf3.drop([\"_id\",\"mods\"], axis = 1, inplace = True)",
"_____no_output_____"
],
[
"df3.head(20)",
"_____no_output_____"
],
[
"col = df3['attrib_id'].unique()\nind = df3['beatmap_id'].unique()\nDF = pd.DataFrame(columns=col, index=ind)\n\n\ng=df3.groupby(['beatmap_id', 'attrib_id'])\n\nfor name, group in g:\n bmap = name[0]\n attr = name[1]\n val = float(group['value'])\n DF.at[bmap, attr] = val\n\n\nDF.head()",
"_____no_output_____"
],
[
"DF.columns = [\"Aim\", \"Speed\", \"OD\", \"AR\", \"Max_Combo\", \"Strain\", \"Star Difficulty\"]",
"_____no_output_____"
],
[
"DF.reset_index()",
"_____no_output_____"
],
[
"correlation = DF.astype('float64').corr()\nf, ax = plt.subplots(figsize = (14, 12))\nplt.title(\"Correlation of Attributes\")\nsns.heatmap(correlation, annot = True)\nplt.show()\n\n",
"_____no_output_____"
],
[
"# collections = db.list_collection_names() \n# print (\"collections:\", collections, \"\\n\")\n\n#All of the collection in the database",
"_____no_output_____"
]
],
[
[
"## Objective 8: Conclusion",
"_____no_output_____"
]
],
[
[
"# Attribute AR is left skewed\n# Attrib Max Combo is right skewed\n# Aim and Star Difficulty, Strain and Star Dificulty are highly correlated \n# Speed and OD, AR and OD are highly correlated \n# Players tend ",
"_____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",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
]
] |
ecea2d1de6c6459aed5dd91347d7cf4b819052f9 | 95,457 | ipynb | Jupyter Notebook | persistence-example.ipynb | scotthellman/discrete-topology | 6182fe607868d88c462c185be8629a35ad2d7c37 | [
"MIT"
] | null | null | null | persistence-example.ipynb | scotthellman/discrete-topology | 6182fe607868d88c462c185be8629a35ad2d7c37 | [
"MIT"
] | null | null | null | persistence-example.ipynb | scotthellman/discrete-topology | 6182fe607868d88c462c185be8629a35ad2d7c37 | [
"MIT"
] | null | null | null | 667.531469 | 30,768 | 0.938904 | [
[
[
"import numpy as np\nimport matplotlib.pyplot as plt\nimport networkx as nx\nimport graph\nimport morsesmale\nimport scipy.spatial\n%matplotlib inline\n\nfunc = lambda x : x**3 + x**2 - 1*x\npoints = np.linspace(-2,2,50)\nfunc_vals = [func(x) for x in points]\nprint(points)\nprint(func_vals)",
"[-2. -1.91836735 -1.83673469 -1.75510204 -1.67346939 -1.59183673\n -1.51020408 -1.42857143 -1.34693878 -1.26530612 -1.18367347 -1.10204082\n -1.02040816 -0.93877551 -0.85714286 -0.7755102 -0.69387755 -0.6122449\n -0.53061224 -0.44897959 -0.36734694 -0.28571429 -0.20408163 -0.12244898\n -0.04081633 0.04081633 0.12244898 0.20408163 0.28571429 0.36734694\n 0.44897959 0.53061224 0.6122449 0.69387755 0.7755102 0.85714286\n 0.93877551 1.02040816 1.10204082 1.18367347 1.26530612 1.34693878\n 1.42857143 1.51020408 1.59183673 1.67346939 1.75510204 1.83673469\n 1.91836735 2. ]\n[-2.0, -1.4613468877763509, -0.98606872986595717, -0.57090158012392789, -0.21258149240537572, 0.092155479434588905, 0.34657328154085487, 0.55393586005830886, 0.7175071611318411, 0.84055113090633982, 0.92633171552669391, 0.97811286113779139, 0.99915851388452093, 0.99273261991177153, 0.96209912536443154, 0.91052197638738974, 0.84126511912553448, 0.75759249972375453, 0.6627680643269388, 0.56005575907997529, 0.45271953012775312, 0.34402332361516047, 0.23723108568708645, 0.1356067624884191, 0.04241430016404734, -0.03908235514114021, -0.10561925728225463, -0.153932460114408, -0.18075801749271136, -0.18283198327227601, -0.15689041130821363, -0.099669355455635267, -0.0079048695696524174, 0.12166699249462365, 0.2923101768820815, 0.50728862973760824, 0.76986629720609501, 1.0833071254324294, 1.4508750605615002, 1.8758340487381933, 2.3614480361074017, 2.9109809688140129, 3.5276967930029142, 4.2148594548189955, 4.9757329004071389, 5.8135810759122437, 6.7316679274791928, 7.7332574012528763, 8.8216134433781832, 10.0]\n"
],
[
"pairs = scipy.spatial.distance.pdist(points.reshape(len(points), 1))\npdist = scipy.spatial.distance.squareform(pairs)\nG = graph.generate_knn_graph(pdist, 2)\nmorsesmale.find_extrema(G, pdist, func_vals)\nfiltrations = morsesmale.get_filtrations(pdist, func_vals, 2)",
"_____no_output_____"
],
[
"colors = ['r','b','k']\ncolor_map = {crystal:colors[i] for i,crystal in enumerate(filtrations[0])}\nfor filtration in filtrations:\n reverse_lookup = {}\n for crystal,vertices in filtration.items():\n for v in vertices:\n reverse_lookup[v] = crystal\n c = [color_map[reverse_lookup[v]] for v in range(len(points))]\n plt.scatter(points, func_vals, c=c, s=200)\n plt.gcf().set_size_inches(12,8)\n plt.show()",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code"
]
] |
ecea3458292a22164b0bfd44d8558e8385e6541c | 232,495 | ipynb | Jupyter Notebook | notebooks/2020_03_17_Replay_Distance_on_Linear_Track.ipynb | edeno/pose_analysis | eb3e435e01f3a084a32eaefaab85738e03522155 | [
"MIT"
] | 1 | 2020-08-08T17:07:41.000Z | 2020-08-08T17:07:41.000Z | notebooks/2020_03_17_Replay_Distance_on_Linear_Track.ipynb | edeno/pose_analysis | eb3e435e01f3a084a32eaefaab85738e03522155 | [
"MIT"
] | null | null | null | notebooks/2020_03_17_Replay_Distance_on_Linear_Track.ipynb | edeno/pose_analysis | eb3e435e01f3a084a32eaefaab85738e03522155 | [
"MIT"
] | null | null | null | 384.925497 | 153,844 | 0.911929 | [
[
[
"%matplotlib inline\n%reload_ext autoreload\n%autoreload 2\n%config InlineBackend.figure_format = 'retina'",
"_____no_output_____"
],
[
"import matplotlib.pyplot as plt\nimport numpy as np\nimport xarray as xr\nimport seaborn as sns\nimport logging\n\nFORMAT = '%(asctime)s %(message)s'\n\nlogging.basicConfig(level='INFO', format=FORMAT, datefmt='%d-%b-%y %H:%M:%S')\nsns.set_context(\"talk\")",
"_____no_output_____"
],
[
"from src.load_data import load_data\n\nepoch_key = ('Jaq', 1, 4) # animal, day, epoch\n\ndata = load_data(epoch_key)",
"_____no_output_____"
],
[
"fig, ax = plt.subplots(figsize=(30, 10))\n\nfor edge_label, df in data['position_info'].groupby('track_segment_id'):\n ax.scatter(df.index / np.timedelta64(1, 's'), df.linear_position, s=1)\n \nax.set_ylabel('Position [cm]')\nax.set_xlabel('Time [s]');",
"_____no_output_____"
],
[
"from src.load_data import make_track_graph\nfrom src.parameters import ANIMALS\n\ntrack_graph, center_well_id = make_track_graph(epoch_key, ANIMALS)",
"_____no_output_____"
],
[
"from loren_frank_data_processing.track_segment_classification import plot_track\n\nplt.plot(data['position_info'].tail_x, data['position_info'].tail_y, color=\"lightgrey\", alpha=0.7, zorder=-1)\nplot_track(track_graph)\nsns.despine(left=True, bottom=True)\n\ncenter_well_id",
"_____no_output_____"
],
[
"is_running = np.abs(data[\"position_info\"].tail_vel) > 4\nEDGE_ORDER = [0]\nEDGE_SPACING = 0",
"_____no_output_____"
],
[
"from replay_trajectory_classification import ClusterlessClassifier\nfrom src.parameters import classifier_parameters, discrete_state_transition\n\nfrom sklearn.model_selection import KFold\nfrom tqdm.auto import tqdm\n\ncv = KFold()\ncv_classifier_clusterless_results = []\n\nfor fold_ind, (train, test) in enumerate(cv.split(data[\"position_info\"].index)):\n logging.info(f\"Fold #{fold_ind}\")\n cv_classifier = ClusterlessClassifier(**classifier_parameters)\n\n cv_classifier.fit(\n position=data[\"position_info\"].iloc[train].linear_position,\n multiunits=data[\"multiunits\"].isel(time=train),\n is_training=is_running.iloc[train],\n track_graph=track_graph,\n center_well_id=center_well_id,\n edge_order=EDGE_ORDER,\n edge_spacing=EDGE_SPACING,\n )\n cv_classifier.discrete_state_transition_ = discrete_state_transition\n logging.info('Predicting posterior...')\n cv_classifier_clusterless_results.append(\n cv_classifier.predict(\n data[\"multiunits\"].isel(time=test),\n time=data[\"position_info\"].iloc[test].index / np.timedelta64(1, \"s\"),\n )\n )\nlogging.info(\"Done...\")",
"17-Mar-20 11:28:02 Fold #0\n17-Mar-20 11:28:02 Fitting initial conditions...\n17-Mar-20 11:28:03 Fitting state transition...\n17-Mar-20 11:28:03 Fitting multiunits...\n17-Mar-20 11:28:04 Predicting posterior...\n17-Mar-20 11:38:17 Fold #1\n17-Mar-20 11:38:17 Fitting initial conditions...\n17-Mar-20 11:38:17 Fitting state transition...\n17-Mar-20 11:38:17 Fitting multiunits...\n17-Mar-20 11:38:18 Predicting posterior...\n17-Mar-20 11:47:52 Fold #2\n17-Mar-20 11:47:52 Fitting initial conditions...\n17-Mar-20 11:47:52 Fitting state transition...\n17-Mar-20 11:47:52 Fitting multiunits...\n17-Mar-20 11:47:53 Predicting posterior...\n17-Mar-20 11:57:16 Fold #3\n17-Mar-20 11:57:16 Fitting initial conditions...\n17-Mar-20 11:57:16 Fitting state transition...\n17-Mar-20 11:57:16 Fitting multiunits...\n17-Mar-20 11:57:16 Predicting posterior...\n17-Mar-20 12:06:37 Fold #4\n17-Mar-20 12:06:37 Fitting initial conditions...\n17-Mar-20 12:06:37 Fitting state transition...\n17-Mar-20 12:06:38 Fitting multiunits...\n17-Mar-20 12:06:38 Predicting posterior...\n17-Mar-20 12:15:56 Done...\n"
],
[
"# concatenate cv classifier results \ncv_classifier_clusterless_results = xr.concat(\n cv_classifier_clusterless_results, dim=\"time\"\n)\ncv_classifier_clusterless_results",
"_____no_output_____"
],
[
"# save the results as .nc format. ncread matlab can read these\ncv_classifier_clusterless_results.to_netcdf(\n f\"{epoch_key[0]}_{epoch_key[1]:02d}_{epoch_key[2]:02d}_cv_classifier_clusterless_vel_4_tail_alltime_results.nc\"\n)",
"_____no_output_____"
],
[
"from src.analysis import calculate_replay_distance\n\ncalculate_replay_distance(cv_classifier_clusterless_results.isel(time=slice(0, 1000)).acausal_posterior.sum(\"state\"),\n track_graph,\n cv_classifier,\n data[\"position_info\"].iloc[slice(0, 1000)].loc[:, [\"tail_x\", \"tail_y\"]],\n data[\"position_info\"].iloc[slice(0, 1000)].track_segment_id\n )",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ecea39b50b645e3360cefffcc61cb9525bfef9ee | 1,837 | ipynb | Jupyter Notebook | notebooks/test_shapefile.ipynb | DFS-UCU/FoodSecurity | eba0b543635cd62482eb2846d63f489881630317 | [
"MIT"
] | 17 | 2017-11-27T19:58:38.000Z | 2022-02-07T01:13:44.000Z | notebooks/test_shapefile.ipynb | DFS-UCU/FoodSecurity | eba0b543635cd62482eb2846d63f489881630317 | [
"MIT"
] | null | null | null | notebooks/test_shapefile.ipynb | DFS-UCU/FoodSecurity | eba0b543635cd62482eb2846d63f489881630317 | [
"MIT"
] | 6 | 2019-08-21T11:42:08.000Z | 2021-03-26T09:59:40.000Z | 1,837 | 1,837 | 0.606968 | [
[
[
"# pip install pyshp \nimport shapefile\nimport matplotlib.pyplot as plt",
"_____no_output_____"
],
[
"#make sure you have file \"data/yield/2017_wheat.shp\"\nsf = shapefile.Reader(\"../data/yield/2017_wheat.shp\")",
"_____no_output_____"
],
[
"shapes = sf.shapes()\nlen(shapes)",
"_____no_output_____"
],
[
"bbox = shapes[3].bbox\n['%.3f' % coord for coord in bbox]",
"_____no_output_____"
],
[
"len(shapes[3].points)",
"_____no_output_____"
],
[
"plt.figure()\nfor shape in sf.shapeRecords():\n x = [i[0] for i in shape.shape.points[:]]\n y = [i[1] for i in shape.shape.points[:]]\n plt.plot(x,y)\nplt.show()",
"_____no_output_____"
],
[
"sf.fields",
"_____no_output_____"
],
[
"records = sf.records()\nrecords[3]",
"_____no_output_____"
],
[
"help(sf)",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ecea40faf0abcd7ec55daf5fd129ecac1e267aae | 20,338 | ipynb | Jupyter Notebook | Samples/K_Fold_test.ipynb | davidfreire/KFold_project | 4a69f264bec6f7e7ecc090ee2d1457453fb3e94c | [
"MIT"
] | null | null | null | Samples/K_Fold_test.ipynb | davidfreire/KFold_project | 4a69f264bec6f7e7ecc090ee2d1457453fb3e94c | [
"MIT"
] | null | null | null | Samples/K_Fold_test.ipynb | davidfreire/KFold_project | 4a69f264bec6f7e7ecc090ee2d1457453fb3e94c | [
"MIT"
] | 1 | 2019-07-04T13:04:23.000Z | 2019-07-04T13:04:23.000Z | 37.873371 | 132 | 0.52011 | [
[
[
"Interesting lecture: https://machinelearningmastery.com/k-fold-cross-validation/",
"_____no_output_____"
]
],
[
[
"import sys\nsys.path.insert(0, '../') #to load KFold",
"_____no_output_____"
],
[
"from keras import Input, optimizers\nfrom keras.layers import Conv2D, MaxPool2D, Flatten, Dense, Dropout\nfrom keras.models import Model\nfrom KFold import K_Fold",
"Using TensorFlow backend.\n"
]
],
[
[
"### First, it is important to understand differences between ShuffleSplit and KFold",
"_____no_output_____"
]
],
[
[
"from sklearn.model_selection import StratifiedShuffleSplit, StratifiedKFold\n\nsplits = 5\n\ntx = range(10)\nty = [0] * 5 + [1] * 5\n\nkfold = StratifiedKFold(n_splits=splits, shuffle=True, random_state=42)\nshufflesplit = StratifiedShuffleSplit(n_splits=splits, random_state=42, test_size=2)\n\nprint(\"KFold\")\nfor train_index, test_index in kfold.split(tx, ty):\n print(\"TRAIN:\", train_index, \"TEST:\", test_index)\n\nprint(\"Shuffle Split\")\nfor train_index, test_index in shufflesplit.split(tx, ty):\n print(\"TRAIN:\", train_index, \"TEST:\", test_index)",
"KFold\nTRAIN: [0 2 3 4 5 7 8 9] TEST: [1 6]\nTRAIN: [0 1 2 3 5 6 7 8] TEST: [4 9]\nTRAIN: [0 1 3 4 5 6 8 9] TEST: [2 7]\nTRAIN: [1 2 3 4 6 7 8 9] TEST: [0 5]\nTRAIN: [0 1 2 4 5 6 7 9] TEST: [3 8]\nShuffle Split\nTRAIN: [8 4 1 0 6 5 7 2] TEST: [3 9]\nTRAIN: [7 0 3 9 4 5 1 6] TEST: [8 2]\nTRAIN: [1 2 5 6 4 8 9 0] TEST: [3 7]\nTRAIN: [4 6 7 8 3 5 1 2] TEST: [9 0]\nTRAIN: [7 2 6 5 4 3 0 9] TEST: [1 8]\n"
],
[
"# In KFolds, each test set should not overlap, even with shuffle. \n# With KFolds and shuffle, the data is shuffled once at the start, and then divided into the number of desired splits. \n# The test data is always one of the splits, the train data is the rest.\n\n# In ShuffleSplit, the data is shuffled every time, and then split. \n# This means the test sets may overlap between the splits:\n# Test, first row 3 and third row 3, first row 9 and fourth row 9.",
"_____no_output_____"
],
[
"# Thus, in ShuffleSplit test_size can be specified, for instance .2 means 1-.2 = .8 for training.\n# While, KFolds depends on the size of the data and K (test set should not overlap), thus, if data is len 10, \n# and K is 5, then test size is 10/5=2 in order to never overlap.",
"_____no_output_____"
]
],
[
[
"### Second, let's create the K-Fold cross validation",
"_____no_output_____"
]
],
[
[
"DB_Path = '/floyd/input/db1/small_dataset/train'",
"_____no_output_____"
]
],
[
[
"The general procedure is as follows:\n\nShuffle the dataset randomly. ok\nSplit the dataset into k groups ok\nFor each unique group:\nTake the group as a hold out or test data set\nTake the remaining groups as a training data set\nFit a model on the training set and evaluate it on the test set\nRetain the evaluation score and discard the model\nSummarize the skill of the model using the sample of model evaluation scores",
"_____no_output_____"
]
],
[
[
"#To save history dict\nimport pickle \ndef save_obj(obj, name):\n with open(name, 'wb') as f:\n pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)\n\ndef load_obj(name):\n with open(name, 'rb') as f:\n return pickle.load(f)",
"_____no_output_____"
],
[
"def get_model():\n \n entrada= Input(shape=(150,150,3))\n \n conv = Conv2D(filters=32, kernel_size=3, activation='relu', name='conv_1')(entrada)\n maxpool = MaxPool2D(pool_size=2, strides=2, name='maxpool_1')(conv)\n \n conv = Conv2D(filters=64, kernel_size=3, activation='relu', name='conv_2')(maxpool)\n maxpool = MaxPool2D(pool_size=2, strides=2, name='maxpool_2')(conv) \n \n conv = Conv2D(filters=128, kernel_size=3, activation='relu', name='conv_3')(maxpool)\n maxpool = MaxPool2D(pool_size=2, strides=2, name='maxpool_3')(conv)\n \n conv = Conv2D(filters=128, kernel_size=3, activation='relu', name='conv_4')(maxpool)\n maxpool = MaxPool2D(pool_size=2, strides=2, name='maxpool_4')(conv)\n \n flat = Flatten(name='flatten')(maxpool)\n #drop = Dropout(rate=.5, name='dropout')(flat)\n \n dense = Dense(units=512, activation='relu', name='Dense1')(flat)#(drop)\n output = Dense(units=1, activation='sigmoid', name='output')(dense)\n #output = Dense(units=2, activation='softmax', name='output')(dense)\n \n model = Model(entrada, output)\n \n #model.compile(optimizer=optimizers.RMSprop(lr=0.001), loss='categorical_crossentropy', metrics=['acc'])\n model.compile(optimizer=optimizers.RMSprop(lr=0.001), loss='binary_crossentropy', metrics=['acc'])\n \n return model",
"_____no_output_____"
],
[
"#Generator parameters\ntraingen_params = {\n 'rescale': 1./255\n}\n\ntestgen_params = {\n 'rescale': 1./255\n}\n\n# Train parameters\ntrain_params = {\n 'batch_size': 20,\n 'target_size': (150,150),\n 'class_mode': 'binary', #'categorical',\n}\n\ntest_params = {\n 'batch_size': 20,\n 'target_size': (150,150),\n 'class_mode': 'binary', #'categorical',\n}\n\nfit_params = {\n 'epochs':10,\n 'shuffle':True,\n 'verbose':1\n}",
"_____no_output_____"
],
[
"KF = K_Fold(DB_Path, 4)",
"_____no_output_____"
],
[
"model = get_model()",
"_____no_output_____"
],
[
"KF.Check_Folds()",
"There are 4 Folds\n\nFold 0\nFor training, 1500 samples: {'cats': 750, 'dogs': 750}\nFor testing, 500 samples: {'cats': 250, 'dogs': 250}\nFirst five X_train images: \n['/floyd/input/db1/small_dataset/train/cats/cat.932.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.901.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.922.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.974.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.492.jpg']\nFirst five X_val images: \n['/floyd/input/db1/small_dataset/train/cats/cat.391.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.980.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.524.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.571.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.699.jpg']\n\nFold 1\nFor training, 1500 samples: {'cats': 750, 'dogs': 750}\nFor testing, 500 samples: {'cats': 250, 'dogs': 250}\nFirst five X_train images: \n['/floyd/input/db1/small_dataset/train/cats/cat.932.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.901.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.922.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.974.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.492.jpg']\nFirst five X_val images: \n['/floyd/input/db1/small_dataset/train/cats/cat.621.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.416.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.591.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.690.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.577.jpg']\n\nFold 2\nFor training, 1500 samples: {'cats': 750, 'dogs': 750}\nFor testing, 500 samples: {'cats': 250, 'dogs': 250}\nFirst five X_train images: \n['/floyd/input/db1/small_dataset/train/cats/cat.901.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.974.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.492.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.391.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.621.jpg']\nFirst five X_val images: \n['/floyd/input/db1/small_dataset/train/cats/cat.932.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.922.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.326.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.348.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.453.jpg']\n\nFold 3\nFor training, 1500 samples: {'cats': 750, 'dogs': 750}\nFor testing, 500 samples: {'cats': 250, 'dogs': 250}\nFirst five X_train images: \n['/floyd/input/db1/small_dataset/train/cats/cat.932.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.922.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.326.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.348.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.391.jpg']\nFirst five X_val images: \n['/floyd/input/db1/small_dataset/train/cats/cat.901.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.974.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.492.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.279.jpg'\n '/floyd/input/db1/small_dataset/train/cats/cat.724.jpg']\n"
],
[
"hist = KF.Apply_KFold(model, traingen_params, testgen_params, train_params, test_params, fit_params)",
"\nFold 0\nFound 1500 images belonging to 2 classes.\nFound 500 images belonging to 2 classes.\nTraining\nEpoch 1/10\n75/75 [==============================] - 12s 154ms/step - loss: 0.7573 - acc: 0.4993 - val_loss: 0.6928 - val_acc: 0.5000\nEpoch 2/10\n75/75 [==============================] - 10s 136ms/step - loss: 0.6962 - acc: 0.5240 - val_loss: 0.6901 - val_acc: 0.6120\nEpoch 3/10\n75/75 [==============================] - 10s 136ms/step - loss: 0.6957 - acc: 0.6060 - val_loss: 0.6578 - val_acc: 0.6340\nEpoch 4/10\n75/75 [==============================] - 10s 135ms/step - loss: 0.6377 - acc: 0.6427 - val_loss: 0.6534 - val_acc: 0.6240\nEpoch 5/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.5843 - acc: 0.6853 - val_loss: 0.5846 - val_acc: 0.7280\nEpoch 6/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.5369 - acc: 0.7347 - val_loss: 0.5735 - val_acc: 0.7260\nEpoch 7/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.4900 - acc: 0.7680 - val_loss: 0.5950 - val_acc: 0.7100\nEpoch 8/10\n75/75 [==============================] - 10s 136ms/step - loss: 0.4404 - acc: 0.7867 - val_loss: 0.6886 - val_acc: 0.7080\nEpoch 9/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.3889 - acc: 0.8173 - val_loss: 0.6381 - val_acc: 0.7400\nEpoch 10/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.3176 - acc: 0.8547 - val_loss: 0.7398 - val_acc: 0.7040\n\nFold 1\nFound 1500 images belonging to 2 classes.\nFound 500 images belonging to 2 classes.\nTraining\nEpoch 1/10\n75/75 [==============================] - 11s 153ms/step - loss: 0.7556 - acc: 0.4980 - val_loss: 0.6921 - val_acc: 0.6140\nEpoch 2/10\n75/75 [==============================] - 10s 138ms/step - loss: 0.6943 - acc: 0.5660 - val_loss: 0.6786 - val_acc: 0.5260\nEpoch 3/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.6748 - acc: 0.6207 - val_loss: 0.6589 - val_acc: 0.6160\nEpoch 4/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.6264 - acc: 0.6633 - val_loss: 0.5771 - val_acc: 0.7180\nEpoch 5/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.5782 - acc: 0.7093 - val_loss: 0.6399 - val_acc: 0.6800\nEpoch 6/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.5206 - acc: 0.7427 - val_loss: 0.6180 - val_acc: 0.6980\nEpoch 7/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.4661 - acc: 0.7827 - val_loss: 0.5611 - val_acc: 0.7000\nEpoch 8/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.4075 - acc: 0.8147 - val_loss: 0.5899 - val_acc: 0.7140\nEpoch 9/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.3498 - acc: 0.8420 - val_loss: 0.6385 - val_acc: 0.6840\nEpoch 10/10\n75/75 [==============================] - 10s 138ms/step - loss: 0.2767 - acc: 0.8813 - val_loss: 0.8172 - val_acc: 0.6680\n\nFold 2\nFound 1500 images belonging to 2 classes.\nFound 500 images belonging to 2 classes.\nTraining\nEpoch 1/10\n75/75 [==============================] - 11s 151ms/step - loss: 0.7338 - acc: 0.4987 - val_loss: 0.6909 - val_acc: 0.6180\nEpoch 2/10\n75/75 [==============================] - 10s 136ms/step - loss: 0.7080 - acc: 0.5407 - val_loss: 0.6876 - val_acc: 0.5640\nEpoch 3/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.6912 - acc: 0.5920 - val_loss: 0.7144 - val_acc: 0.6300\nEpoch 4/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.6697 - acc: 0.6280 - val_loss: 0.6691 - val_acc: 0.6060\nEpoch 5/10\n75/75 [==============================] - 10s 136ms/step - loss: 0.6073 - acc: 0.6773 - val_loss: 0.5641 - val_acc: 0.6940\nEpoch 6/10\n75/75 [==============================] - 10s 135ms/step - loss: 0.5780 - acc: 0.7233 - val_loss: 0.5822 - val_acc: 0.7020\nEpoch 7/10\n75/75 [==============================] - 10s 138ms/step - loss: 0.5881 - acc: 0.7560 - val_loss: 0.6802 - val_acc: 0.6660\nEpoch 8/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.4517 - acc: 0.7800 - val_loss: 0.6135 - val_acc: 0.6800\nEpoch 9/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.4113 - acc: 0.8113 - val_loss: 0.6037 - val_acc: 0.7180\nEpoch 10/10\n75/75 [==============================] - 10s 138ms/step - loss: 0.3498 - acc: 0.8540 - val_loss: 0.7174 - val_acc: 0.6800\n\nFold 3\nFound 1500 images belonging to 2 classes.\nFound 500 images belonging to 2 classes.\nTraining\nEpoch 1/10\n75/75 [==============================] - 11s 151ms/step - loss: 0.7114 - acc: 0.5080 - val_loss: 0.6907 - val_acc: 0.5980\nEpoch 2/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.7049 - acc: 0.5613 - val_loss: 0.6759 - val_acc: 0.5920\nEpoch 3/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.6653 - acc: 0.6227 - val_loss: 0.6750 - val_acc: 0.5600\nEpoch 4/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.6402 - acc: 0.6433 - val_loss: 0.6386 - val_acc: 0.6460\nEpoch 5/10\n75/75 [==============================] - 10s 140ms/step - loss: 0.5794 - acc: 0.7007 - val_loss: 0.6564 - val_acc: 0.6420\nEpoch 6/10\n75/75 [==============================] - 10s 135ms/step - loss: 0.5122 - acc: 0.7553 - val_loss: 0.6319 - val_acc: 0.6700\nEpoch 7/10\n75/75 [==============================] - 10s 138ms/step - loss: 0.4448 - acc: 0.7940 - val_loss: 0.6115 - val_acc: 0.7080\nEpoch 8/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.3882 - acc: 0.8180 - val_loss: 0.8759 - val_acc: 0.6860\nEpoch 9/10\n75/75 [==============================] - 10s 136ms/step - loss: 0.3494 - acc: 0.8480 - val_loss: 0.6936 - val_acc: 0.6980\nEpoch 10/10\n75/75 [==============================] - 10s 137ms/step - loss: 0.2821 - acc: 0.8820 - val_loss: 0.7675 - val_acc: 0.7200\n"
],
[
"import numpy as np\nfor key, val in hist.items():\n print('{0}: {1}'.format(key, np.mean(np.array(val))))",
"val_loss: 0.7604647065699102\nval_acc: 0.6929999971389771\nloss: 0.30655239490171277\nacc: 0.8679999987284343\n"
],
[
"save_obj(hist,'hist_config1.pkl')",
"_____no_output_____"
],
[
"hist_retr = load_obj('hist_config1.pkl')",
"_____no_output_____"
],
[
"for key, val in hist_retr.items():\n print('{0}: {1}'.format(key, np.mean(np.array(val))))",
"val_loss: 0.7604647065699102\nval_acc: 0.6929999971389771\nloss: 0.30655239490171277\nacc: 0.8679999987284343\n"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ecea4a69dd6e0915d637f068a6f71ec630e52608 | 8,115 | ipynb | Jupyter Notebook | ray-rllib/explore-rllib/extras/Extra-Application-Taxi.ipynb | ewbolme/academy | 87bda18d4122dbaa3f67d3a1f6c4b534bd279992 | [
"Apache-2.0"
] | null | null | null | ray-rllib/explore-rllib/extras/Extra-Application-Taxi.ipynb | ewbolme/academy | 87bda18d4122dbaa3f67d3a1f6c4b534bd279992 | [
"Apache-2.0"
] | null | null | null | ray-rllib/explore-rllib/extras/Extra-Application-Taxi.ipynb | ewbolme/academy | 87bda18d4122dbaa3f67d3a1f6c4b534bd279992 | [
"Apache-2.0"
] | null | null | null | 31.823529 | 384 | 0.580283 | [
[
[
"# Ray RLlib - Extra Application Example - Taxi-v3\n\n© 2019-2020, Anyscale. All Rights Reserved\n\n\n\nThis example uses [RLlib](https://ray.readthedocs.io/en/latest/rllib.html) to train a policy with the `Taxi-v3` environment ([gym.openai.com/envs/Taxi-v3/](https://gym.openai.com/envs/Taxi-v3/)). The goal is to pick up passengers as fast as possible, negotiating the available paths. This is one of OpenAI Gym's [\"toy text\"](https://gym.openai.com/envs/#toy_text) problems.\n\nFor more background about this problem, see:\n\n* [\"Hierarchical Reinforcement Learning with the MAXQ Value Function Decomposition\"](https://arxiv.org/abs/cs/9905014), [Thomas G. Dietteric](https://twitter.com/tdietterich)\n* [\"Reinforcement Learning: let’s teach a taxi-cab how to drive\"](https://towardsdatascience.com/reinforcement-learning-lets-teach-a-taxi-cab-how-to-drive-4fd1a0d00529), [Valentina Alto](https://twitter.com/AltoValentina)",
"_____no_output_____"
]
],
[
[
"import pandas as pd\nimport json\nimport os\nimport shutil\nimport sys\nimport ray\nimport ray.rllib.agents.ppo as ppo",
"_____no_output_____"
],
[
"info = ray.init(ignore_reinit_error=True)",
"_____no_output_____"
],
[
"print(\"Dashboard URL: http://{}\".format(info[\"webui_url\"]))",
"_____no_output_____"
]
],
[
[
"Set up the checkpoint location:",
"_____no_output_____"
]
],
[
[
"checkpoint_root = \"tmp/ppo/taxi\"\nshutil.rmtree(checkpoint_root, ignore_errors=True, onerror=None) # clean up old runs",
"_____no_output_____"
]
],
[
[
"Next we'll train an RLlib policy with the `Taxi-v3` environment.\n\nBy default, training runs for `10` iterations. Increase the `N_ITER` setting if you want to see the resulting rewards improve.\nAlso note that *checkpoints* get saved after each iteration into the `/tmp/ppo/taxi` directory.\n\n> **Note:** If you prefer to use a different directory root than `/tmp`, change it in the next cell **and** in the `rllib rollout` command below.",
"_____no_output_____"
]
],
[
[
"SELECT_ENV = \"Taxi-v3\"\nN_ITER = 10\n\nconfig = ppo.DEFAULT_CONFIG.copy()\nconfig[\"log_level\"] = \"WARN\"\n\nagent = ppo.PPOTrainer(config, env=SELECT_ENV)",
"_____no_output_____"
],
[
"results = []\nepisode_data = []\nepisode_json = []\n\nfor n in range(N_ITER):\n result = agent.train()\n results.append(result)\n \n episode = {'n': n, \n 'episode_reward_min': result['episode_reward_min'], \n 'episode_reward_mean': result['episode_reward_mean'], \n 'episode_reward_max': result['episode_reward_max'], \n 'episode_len_mean': result['episode_len_mean']\n }\n \n episode_data.append(episode)\n episode_json.append(json.dumps(episode))\n file_name = agent.save(checkpoint_root)\n \n print(f'{n+1:3d}: Min/Mean/Max reward: {result[\"episode_reward_min\"]:8.4f}/{result[\"episode_reward_mean\"]:8.4f}/{result[\"episode_reward_max\"]:8.4f}, len mean: {result[\"episode_len_mean\"]:8.4f}. Checkpoint saved to {file_name}')",
"_____no_output_____"
]
],
[
[
"Do the episode rewards increase after multiple iterations?\n\nAlso, print out the policy and model to see the results of training in detail…",
"_____no_output_____"
]
],
[
[
"import pprint\n\npolicy = agent.get_policy()\nmodel = policy.model\n\npprint.pprint(model.variables())\npprint.pprint(model.value_function())\n\nprint(model.base_model.summary())",
"_____no_output_____"
]
],
[
[
"## Rollout\n\nNext we'll use the [`rollout` script](https://ray.readthedocs.io/en/latest/rllib-training.html#evaluating-trained-policies) to evaluate the trained policy.\n\nThe output from the following command visualizes the \"taxi\" agent operating within its simulation: picking up a passenger, driving, turning, dropping off a passenger (\"put-down\"), and so on. \n\nA 2-D map of the *observation space* is visualized as text, which needs some decoding instructions:\n\n * `R` -- R(ed) location in the Northwest corner\n * `G` -- G(reen) location in the Northeast corner\n * `Y` -- Y(ellow) location in the Southwest corner\n * `B` -- B(lue) location in the Southeast corner\n * `:` -- cells where the taxi can drive\n * `|` -- obstructions (\"walls\") which the taxi must avoid\n * blue letter represents the current passenger’s location for pick-up\n * purple letter represents the drop-off location\n * yellow rectangle is the current location of our taxi/agent\n\nThat allows for a total of 500 states, and these known states are numbered between 0 and 499.\n\nThe *action space* for the taxi/agent is defined as:\n\n * move the taxi one square North\n * move the taxi one square South\n * move the taxi one square East\n * move the taxi one square West\n * pick-up the passenger\n * put-down the passenger\n\nThe *rewards* are structured as −1 for each action plus:\n\n * +20 points when the taxi performs a correct drop-off for the passenger\n * -10 points when the taxi attempts illegal pick-up/drop-off actions\n\nAdmittedly it'd be better if these state visualizations showed the *reward* along with observations.",
"_____no_output_____"
]
],
[
[
"!rllib rollout \\\n tmp/ppo/taxi/checkpoint_10/checkpoint-10 \\\n --config \"{\\\"env\\\": \\\"Taxi-v3\\\"}\" \\\n --run PPO \\\n --steps 2000",
"_____no_output_____"
],
[
"ray.shutdown() # \"Undo ray.init()\".",
"_____no_output_____"
]
],
[
[
"## Exercise (\"Homework\")\n\nIn addition to _Taxi_, there are other so-called [\"toy text\"](https://gym.openai.com/envs/#toy_text) problems you can try.",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
]
] |
ecea58f0fe3e2bb3d6aec5dc8b96cb7b05604660 | 2,213 | ipynb | Jupyter Notebook | DAY 101 ~ 200/DAY108_[SW Expert Academy] 4522번 세상의 모든 팰린드롬 (Python).ipynb | SOMJANG/CODINGTEST_PRACTICE | 1a7304e9063579441b8a67765175c82b0ad93ac9 | [
"MIT"
] | 15 | 2020-03-17T01:18:33.000Z | 2021-12-24T06:31:06.000Z | DAY 101 ~ 200/DAY108_[SW Expert Academy] 4522번 세상의 모든 팰린드롬 (Python).ipynb | SOMJANG/CODINGTEST_PRACTICE | 1a7304e9063579441b8a67765175c82b0ad93ac9 | [
"MIT"
] | null | null | null | DAY 101 ~ 200/DAY108_[SW Expert Academy] 4522번 세상의 모든 팰린드롬 (Python).ipynb | SOMJANG/CODINGTEST_PRACTICE | 1a7304e9063579441b8a67765175c82b0ad93ac9 | [
"MIT"
] | 10 | 2020-03-17T01:18:34.000Z | 2022-03-30T10:53:07.000Z | 27.6625 | 170 | 0.503389 | [
[
[
"## 2020년 5월 24일 일요일\n### SW Expert Academy - 세상의 모든 팰린드롬\n### 문제 : https://swexpertacademy.com/main/code/problem/problemDetail.do?contestProbId=AWO6Oao6N4QDFAWw&categoryId=AWO6Oao6N4QDFAWw&categoryType=CODE\n### 블로그 : https://somjang.tistory.com/entry/SWExpertAcademy-4522%EB%B2%88-%EC%84%B8%EC%83%81%EC%9D%98-%EB%AA%A8%EB%93%A0-%ED%8C%B0%EB%A6%B0%EB%93%9C%EB%A1%AC-Python",
"_____no_output_____"
],
[
"### 첫번째 시도",
"_____no_output_____"
]
],
[
[
"def check_palindrome(string):\n isPalindrome = \"Exist\"\n last_index = len(string) - 1\n for i in range(len(string) // 2):\n if string[i] != string[last_index - i]:\n isPalindrome = \"Not exist\"\n break\n return isPalindrome\n\ndef change_string(string):\n string = list(string)\n last_index = len(string) - 1 \n for i in range(len(string) // 2):\n if string[i] == '?' and string[last_index - i] != '?':\n string[last_index - i] = '?'\n elif string[i] != '?' and string[last_index - i] == '?':\n string[i] = '?'\n return string\n\nT = int(input())\n \nfor i in range(T):\n input_str = str(input())\n \n change_str = change_string(input_str)\n \n check = check_palindrome(change_str)\n \n print(\"#{} {}\".format(i+1, check))",
"_____no_output_____"
]
]
] | [
"markdown",
"code"
] | [
[
"markdown",
"markdown"
],
[
"code"
]
] |
ecea5b8aa54b2fdbd140ee7af962466145fb0f3d | 9,222 | ipynb | Jupyter Notebook | Notebook/RNN.ipynb | huiwenzhang/100-Days-ML-Note | 1503dff1960bf19b05812fd0d7fc3f633874654f | [
"MIT"
] | 1 | 2019-01-08T04:55:57.000Z | 2019-01-08T04:55:57.000Z | Notebook/RNN.ipynb | huiwenzhang/100-Days-ML-Note | 1503dff1960bf19b05812fd0d7fc3f633874654f | [
"MIT"
] | null | null | null | Notebook/RNN.ipynb | huiwenzhang/100-Days-ML-Note | 1503dff1960bf19b05812fd0d7fc3f633874654f | [
"MIT"
] | 2 | 2019-09-09T07:00:19.000Z | 2019-11-17T04:00:21.000Z | 34.539326 | 287 | 0.553025 | [
[
[
"## ＲＮＮ教程\n- ＲＮN原理简介\n- Basic RNN\n- LSTM\n- CharRNN项目",
"_____no_output_____"
],
[
"## 案例讲解\n通过一个案例讲解如何使用ＲＮＮ．项目目的是用ＬＳＴＭ学习句子生成．训练数据来自于莎士比亚的著作，以文本的形式存储．我们使用多层多步的Ｎ＊Ｎ模型来对这个问题建模．\n比如，输入： how are you?对应的标签就是：ow are you? h．通过上一个字符预测下一个字符．字符构成单词，单词构成句子．\n所以训练集样本就是一个个字符，对应标签也是字符，并且是每个训练样本对应的下一个字符．",
"_____no_output_____"
],
[
"## 代码流程\n### 数据输入\n\n```python\nself.inputs = tf.placeholder(tf.int32, shape=(self.batch_size, self.num_steps),\n name='inputs')\nself.targets = tf.placeholder(tf.int32, shape=(self.batch_size, self.num_steps),\n name='labels')\nself.keep_prob = tf.placeholder(tf.float32, name='keep_prob')\n\nif not self.use_embedding:\n self.rnn_inputs = tf.one_hot(self.inputs, self.n_classes)\nelse:\n embedding = tf.get_variable('embedding', [self.n_classes, self.embedding_size])\n self.rnn_inputs = tf.nn.embedding_lookup(embedding, self.inputs)\n \n```\n**Ｎｏｔｅ:注意这里的维度匹配问题**\n- batch_size:表示一次输入多少个句子，每个句子相当于普通意义下的一个样本．实际上，在模型内部还是一个一个字符输入的．只是使用`tf.nn.rnn_cell．dynamic()`可以自动的把多个字符串起来．看起来的效果就是输入了一个句子\n- num_steps:句子的长度，有多少个字符，或者叫做ＲＮＮ的展开长度\n- rnn_inputs.shape: （ｂａｔch_size， num_steps， dimension of each char）．由于每个字符被表示成了一个ｏｎｅ-hot的向量，因此输入句子中每个字符是多维的\n- 对于汉字的话我们会显式的embedding一下，因此显然每个汉子对应的也是个多维向量\n\n> 为什么汉字不用one-hot编码？\n我们要对输入进行特征表示，计算机只认识数字．你输入字符a，它并不知道什么意思？我们需要把它表示成一段数字，这段数字能够很好的刻画这个字符或者标识这个字符．这就叫做特征提取．对于英文字符，我们可以使用one-hot的形式．什么是one-hot呢？比如我们有猫，狗老鼠三个动物，那么ｏｎｅ-hot表示方法就是：猫＝１００，狗＝０１０，老鼠＝００１．即用每一位表示一个动物，是哪个动物，就激活哪个位置．对于英文字符，总共也就２６个英文字母，加上标点符号等等，顶多也就１００个对象．如果用ｏｎｅ-hot表示，每个对象的向量长度肯定是小于１００的．这个是可以接受的．\n如果是汉字呢？你可能晕了，中国文化如此博大精深，那汉字还能少的了．姑且不说那些生僻字，仅仅是常用的汉字也有３０００多个．如果用one-hot表示，每个样本都是３０００多维的，这肯定不行啊．所以需要引入ｅｍｂｅｄding，你可以理解它赋予了每个汉字一个更加紧凑的表征．\n\n### 模型搭建\n- 利用`tf.nn.rnn_cell.BasicLSTMCell(size)`创建一个基本的ＬＳＴＭ模块\n**Note:**这里的ｓｉｚｅ其实相当于ＭＬＰ中隐含层神经元的个数．这个ｓｉｚｅ容易和ｎｕｍ_step参数混淆．num_step是在一个时间维度上将下面函数定义的cell复制num_steps次．所以每个ｃｅｌｌ都是一样的，包括权重都是一样的．而且每个cell里面有size个神经元，对应每个cell是size维的输出．\n\n```python\ndef create_cell(lstm_size, keep_prob):\n lstm = tf.nn.rnn_cell.BasicLSTMCell(lstm_size)\n drop = tf.nn.rnn_cell.DeviceWrapper(lstm, output_keep_prob=keep_prob)\n return drop\n```\n\n- 堆叠多层的cell\n\n```python\ncell = tf.nn.rnn_cell.MultiRNNCell(\n [create_cell(self.lstm_size, self.keep_prob) for _ in range(self.n_layers)])\nself.init_state = cell.zero_state(self.batch_size,\n tf.float32) # state is the hidden state\n```\n\n- 在时间维度上展开，构成一个句子\n\n```python\nself.lstm_outputs, self.final_state = tf.nn.dynamic_rnn(cell, self.rnn_inputs,\n initial_state=self.init_state)\n```\n\n- 输出．上面的输出的是多步隐藏层输出．每个ｓｔｅｐ是个多维的（本例１２８维），为了得到最后的输出，还需要经过全连接和softmax才能得到每个字符出现的概率（所以最后输出的维度是：(num_steps, num_chars))\n\n```python\nseq_output = tf.concat(self.lstm_outputs, 1)\nx = tf.reshape(seq_output, [-1, self.lstm_size]) # row: bath_size * num_steps\n\nwith tf.variable_scope('output'):\n w = tf.Variable(tf.truncated_normal([self.lstm_size, self.n_classes], stddev=0.1))\n b = tf.Variable(tf.zeros(self.n_classes))\n self.logits = tf.matmul(x, w) + b\n self.preds = tf.nn.softmax(self.logits, name='prob_pred')\n```\n### 计算损失\n\n```python\nlabel = tf.one_hot(self.targets, self.n_classes)\ny = tf.reshape(label, self.logits.get_shape())\nloss = tf.nn.softmax_cross_entropy_with_logits(logits=self.logits, labels=y)\nself.loss = tf.reduce_mean(loss)\n```\n\n### 设置优化器\n\n```python\ntrain_vars = tf.trainable_variables()\ngrads, _ = tf.clip_by_global_norm(tf.gradients(loss, train_vars), self.grid_clip)\noptimizer = tf.train.AdamOptimizer(self.lr)\nself.optimizer = optimizer.apply_gradients(zip(grads, train_vars))\n```\n",
"_____no_output_____"
],
[
"## 训练模型\n```\nself.session = tf.Session()\nwith self.session as sess:\n sess.run(tf.global_variables_initializer())\n step = 0\n new_state = sess.run(self.init_state)\n for x, y in batch_generator:\n start = time.time()\n feed_dict = {self.inputs: x, self.targets: y, self.keep_prob: self.train_keep_prob,\n self.init_state: new_state}\n batch_loss, new_state, prob, _ = sess.run(\n [self.loss, self.final_state, self.preds, self.optimizer], feed_dict=feed_dict)\n step += 1\n end = time.time()\n\n # print out\n if step % log_interval == 0:\n print('Step: {}, Loss: {:.4f}, Time: {:.4f}'.format(step, batch_loss,\n end - start))\n if step % save_interval == 0:\n self.saver.save(sess, os.path.join(save_path, 'model'), global_step=step)\n\n if step > max_steps:\n return\n```\n主要步骤：\n- 准备数据\n- 准备输入：`self.inputs, selt.targets, self.keep_prob, self.init_state`\n- 计算损失，计算隐状态，计算预测输出，执行梯度更新\n",
"_____no_output_____"
],
[
"## 预测模型\n```\nsamples = [c for c in prime]\nnew_state = self.session.run(self.init_state)\npreds = np.ones((vocab_size,))\nfor c in prime:\n x = np.zeros((1, 1))\n x[0, 0] = c\n\n feed_dict = {self.inputs: x,\n self.keep_prob: 1.,\n self.init_state: new_state}\n preds, new_state = self.session.run([self.preds, self.final_state], feed_dict=feed_dict)\n\nc = pick_top_n(preds, vocab_size)\nsamples.append(c)\n\nfor _ in range(n_samples):\n x = np.zeros((1, 1))\n x[0, 0] = c\n feed = {self.inputs: x,\n self.keep_prob: 1.,\n self.init_state: new_state}\n preds, new_state = self.session.run([self.preds, self.final_state],\n feed_dict=feed)\n\n c = pick_top_n(preds, vocab_size)\n samples.append(c)\n\nreturn np.array(samples)\n```\n- 逐个字符的预测\n- 将字符转成对应的索引，预测出来的也是数字，最后把数字串转化称字符",
"_____no_output_____"
],
[
"## 运行\n- 训练莎士比亚\n```bash\npython Notebook/rnn_train.py \\\n --input_file datasets/shakespeare.txt \\\n --name shakespeare \\\n --num_steps 50 \\\n --batch_size 32 \\\n --learning_rate 0.01 \\\n --max_steps 20000\n```\n- 测试莎士比亚\n```bash\npython Notebook/predict.py \\\n --converter_path RNNmodel/shakespeare/vocab.pkl \\\n --checkpoint_path RNNmodel/shakespeare/ \\\n --max_length 1000\n```\n- 训练诗句\n```bash\npython Notebook/rnn_train.py \\\n --use_embedding \\\n --input_file datasets/poetry.txt \\\n --name poetry \\\n --learning_rate 0.005 \\\n --num_steps 26 \\\n --batch_size 32 \\\n --max_steps 80000\n```\n- 测试生成诗句\n```bash\npython Notebook/predict.py \\\n --use_embedding \\\n --converter_path RNNmodel/poetry/vocab.pkl \\\n --checkpoint_path RNNmodel/poetry/ \\\n --max_length 300\n```",
"_____no_output_____"
]
]
] | [
"markdown"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
]
] |
ecea6929a1bfbdab5f881afff7c3343c8d399568 | 889,575 | ipynb | Jupyter Notebook | notebooks/oscillators.ipynb | sbernasek/genessa | b00d3173e9940943a513ab138d14d770bfd3c132 | [
"MIT"
] | 2 | 2020-02-22T09:53:23.000Z | 2020-02-24T19:01:28.000Z | notebooks/oscillators.ipynb | sebastianbernasek/genessa | b00d3173e9940943a513ab138d14d770bfd3c132 | [
"MIT"
] | null | null | null | notebooks/oscillators.ipynb | sebastianbernasek/genessa | b00d3173e9940943a513ab138d14d770bfd3c132 | [
"MIT"
] | null | null | null | 2,207.382134 | 153,448 | 0.959124 | [
[
[
"import numpy as np\nimport matplotlib.pyplot as plt\n \n%reload_ext autoreload\n%autoreload 2\n%matplotlib inline",
"_____no_output_____"
]
],
[
[
"# Example 3: Network of Coupled Circadian Oscillators",
"_____no_output_____"
],
[
"In this example we will simulate a population of coupled circadian oscillators. This simulation is considerably more complex than the previous two examples. We will overcome this problem by using an existing template of a single circadian oscillator available within GeneSSA. This oscillator is based upon a proposed model of the Per-Tim clock network in Drosophila (Gonze et al. 2003).\n\n[1] Gonze, Didier, et al. \"Stochastic models for circadian rhythms: effect of molecular noise on periodic and chaotic behaviour.\" Comptes rendus biologies 326.2 (2003): 189-203.",
"_____no_output_____"
],
[
"",
"_____no_output_____"
],
[
"",
"_____no_output_____"
],
[
"",
"_____no_output_____"
],
[
"",
"_____no_output_____"
],
[
"## Example 3.1: Simulating an individual oscillator\n\nFirst we will simulate a single oscillator operating in isolation.\n\n### Creating an individual Per-Tim oscillator",
"_____no_output_____"
],
[
"We can use GeneSSA to instantiate an individual oscillator. The `transcription` parameter indicates whether or not we should include constitutive transcription of per and tim transcripts, while the `omega` parameter sets the approximate magnitude of Per and Tim protein levels.",
"_____no_output_____"
]
],
[
[
"from genessa.demo.oscillators import Oscillator\n\noscillator = Oscillator(transcription=True, omega=100)",
"_____no_output_____"
]
],
[
[
"The `Oscillator` class inherits from the `Network` class. All `Network` instances provide a `__repr__` attribute that provide a quick summary of all the reactions in the network. This allows us to quickly inspect each of the 30 reactions in our individual oscillator.",
"_____no_output_____"
]
],
[
[
"oscillator",
" Rxn Reactants Products Propensity Parameter\n--------------------------- ----------- ---------- ------------------------- ---------------------\n p decay 0 [0] 0.01000\n P0 translation 1 [0] 0.90000\n P0 decay 1 [1] 0.01000\n t decay 2 [2] 0.01000\n T0 translation 3 [2] 0.90000\n T0 decay 3 [3] 0.01000\n P0 transcript deg. 0 1 / (1 + 20.0/[0]) 70.00000\n T0 transcript deg. 2 1 / (1 + 20.0/[2]) 70.00000\n P0 phosphorylation 1 4 1 / (1 + 200.0/[1]) 800.00000\n P1 dephosphorylation 4 1 1 / (1 + 200.0/[4]) 100.00000\n P1 decay 4 [4] 0.01000\n P1 phosphorylation 4 5 1 / (1 + 200.0/[4]) 800.00000\n P2 dephosphorylation 5 4 1 / (1 + 200.0/[5]) 100.00000\n P2 decay 5 [5] 0.01000\n T0 phosphorylation 3 6 1 / (1 + 200.0/[3]) 800.00000\n T1 dephosphorylation 6 3 1 / (1 + 200.0/[6]) 100.00000\n T1 decay 6 [6] 0.01000\n T1 phosphorylation 6 7 1 / (1 + 200.0/[6]) 800.00000\n T2 dephosphorylation 7 6 1 / (1 + 200.0/[7]) 100.00000\n T2 decay 7 [7] 0.01000\n P2 deg. 5 1 / (1 + 20.0/[5]) 200.00000\n T2 deg. 7 1 / (1 + 20.0/[7]) 200.00000 + 2.0[IN_0]\n C association 5, 7 8 [5][7] 0.01200\n C dissociation 8 5, 7 [8] 0.60000\n C decay 8 [8] 0.01000\n C import 8 9 [8] 0.60000\n C export 9 8 [9] 0.20000\n nC decay 9 [9] 0.01000\n T0 transcription 2 100.00000\nT0 transcription repression 1 / (1 + ([9]/100.0)^4.0)\n P0 transcription 0 100.00000\nP0 transcription repression 1 / (1 + ([9]/100.0)^4.0)\n"
]
],
[
[
"### Simulating an individual Per-Tim oscillator",
"_____no_output_____"
],
[
"We can now run our simulation as we did before, then plot the resultant dynamics of the nuclear Per-Tim complex ($nC$). The `Oscillator.proteins` attribute provides a dictionary that maps species names, such as $nC$, to dimensions of the state space.",
"_____no_output_____"
]
],
[
[
"from genessa.solver.stochastic import MonteCarloSimulation\n\n# define an initial condition\nic = np.ones(oscillator.N)*100\n\n# run simulation\nsimulation = MonteCarloSimulation(oscillator, ic=ic)\ntimeseries = simulation.run(N=1, duration=240, dt=1)\n\n# create figure\nfig, ax = plt.subplots()\nax.set_xlabel('Time (h)')\nax.set_ylabel('Level')\n\n# plot trajectories\nspecies = 'nC'\ndimension = oscillator.proteins[species]\nfor trajectory in timeseries.states[:, dimension, :]:\n ax.plot(timeseries.t, trajectory, '-k')",
"_____no_output_____"
]
],
[
[
"## Example 3.2: Simulating a network of coupled oscillators",
"_____no_output_____"
],
[
"We will now extend our simulation to a network of coupled oscillators. Oscillators are coupled by their transcription rates as detailed by Gonze et al.:",
"_____no_output_____"
],
[
"",
"_____no_output_____"
],
[
"",
"_____no_output_____"
],
[
"",
"_____no_output_____"
],
[
"### Creating a population of Per-Tim oscillators\n\nGeneSSA offers a `CoupledOscillators` template for this purpose. The `replicates` parameter defines the number of oscillators in the network.",
"_____no_output_____"
]
],
[
[
"from genessa.demo.oscillators import CoupledOscillators\n\n# instantiate system of coupled oscillators\nnetwork = CoupledOscillators(omega=100, replicates=5)",
"_____no_output_____"
]
],
[
[
"### Adding transcriptional coupling to the network\n\nOscillators are coupled by providing an adjacency matrix for the network. GeneSSA also provides methods for quick addition of some common coupling strategies. These include a random coupling in which edges are randomly generated, and a dense coupling in which the network is fully connected. We will add a random coupling using the `CoupledOscillators.add_random_coupling` method. The `a` parameter determines the coupling strength, and is equivalent to $\\alpha$ in the model above.\n",
"_____no_output_____"
]
],
[
[
"network.add_random_coupling(a=0.01)",
"_____no_output_____"
]
],
[
[
"### Run stochastic simulation\n\nWe will now run our simulation as we did before.",
"_____no_output_____"
]
],
[
[
"from genessa.solver.stochastic import MonteCarloSimulation\n\n# run simulation\nic = np.ones(network.N)*100\nsimulation = MonteCarloSimulation(network, ic=ic)\ntimeseries = simulation.run(N=1, duration=24*10, dt=1)",
"_____no_output_____"
]
],
[
[
"### Plot simulated dynamics of nuclear Per-Tim complex\n\nNote that the `CoupledOscillators.proteins` attribute provides a dictionary of dictionaries mapping species names to their state space dimensions. This is because each cell in the network has its own list of species.",
"_____no_output_____"
]
],
[
[
"# create figure\nfig, ax = plt.subplots()\nax.set_xlabel('Time (h)')\nax.set_ylabel('Level')\n\n# plot trajectories\nspecies = 'nC'\nfor p in network.proteins.values():\n ax.plot(timeseries.t, timeseries.states[0, p[species], :], '-k')",
"_____no_output_____"
]
]
] | [
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
ecea6989c3326ee4c5d052a8e925e6cd53e18d39 | 46,469 | ipynb | Jupyter Notebook | Mini Project 2 Code.ipynb | ryanvolpi/income_prediction | 0b5ca5d46c8f955d7a0f8f82bce498e6480919f2 | [
"MIT"
] | null | null | null | Mini Project 2 Code.ipynb | ryanvolpi/income_prediction | 0b5ca5d46c8f955d7a0f8f82bce498e6480919f2 | [
"MIT"
] | null | null | null | Mini Project 2 Code.ipynb | ryanvolpi/income_prediction | 0b5ca5d46c8f955d7a0f8f82bce498e6480919f2 | [
"MIT"
] | null | null | null | 44.214082 | 7,260 | 0.560244 | [
[
[
"import pandas as pd\nimport numpy as np\nimport math\nfrom sklearn.impute import SimpleImputer\nimport rpy2.robjects as robjects\nfrom rpy2.robjects.packages import importr\nfrom rpy2.robjects import pandas2ri\nimport rpy2\nfrom matplotlib import pyplot as plt\nfrom sklearn.compose import ColumnTransformer\nfrom sklearn.pipeline import Pipeline\nfrom sklearn.preprocessing import MinMaxScaler\nfrom sklearn.preprocessing import PowerTransformer\nfrom sklearn.preprocessing import OneHotEncoder\nfrom sklearn.preprocessing import StandardScaler\nfrom sklearn.model_selection import GridSearchCV\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.linear_model import LogisticRegression\nfrom mord import LogisticIT\nimport warnings \nimport copy \nwarnings.simplefilter('ignore')\n\nSEED = 777",
"_____no_output_____"
]
],
[
[
"## Load Data",
"_____no_output_____"
]
],
[
[
"col_names = ['income','sex','married','age','education','occupation',\n 'time_in_area','dual_income','num_people_household',\n 'num_children_household','home_status','home_type','ethnicity',\n 'language']\ndf = pd.read_csv('marketing.data', delimiter=\" \",header=None, names=col_names)\n\ndf.head()",
"_____no_output_____"
],
[
"Y = np.array(df['income'])\nX = np.array(df.drop('income',axis=1))\n\nplt.bar(pd.value_counts(Y).index,pd.value_counts(Y).values/len(Y))\nplt.show()\n\nprint(f\"Baseline Accuracy: {pd.value_counts(Y).values[0]/len(Y)}\")",
"_____no_output_____"
]
],
[
[
"Split the data 80-20 into a train and a test set using stratified random sampling to preserve the proportion of classes in the response variable",
"_____no_output_____"
]
],
[
[
"x_train,x_test,y_train,y_test = train_test_split(X,Y, test_size=.2, stratify = Y, random_state = SEED)",
"_____no_output_____"
]
],
[
[
"### Define a KNN Imputer\nDefine a class to impute missing values in each feature using K-Nearest-Neighbors Classifier trained to predict the non-missing values using the other features. Feature classifiers are only fit on the training data in each step and do not see the test or validation data during training. This is to prevent data leakage.",
"_____no_output_____"
]
],
[
[
"class KNNImputer():\n def __init__(self):\n # Try an array of n values for each classifier\n self.model = GridSearchCV(KNeighborsClassifier(),{'n_neighbors':[5,10,15,20]}, cv=3, n_jobs=-1)\n self.model_list = [None]\n self.X = np.array([])\n \n def fit(self, X, verbose = 0):\n # create deep copy to avoid altering the original data\n self.X = copy.deepcopy(X)\n\n if len(self.X.shape)==1 or self.X.shape[1]==0:\n self.X = self.X.reshape(-1,1)\n\n self.model_list = [None]*(self.X.shape[1])\n \n # count of missing values per column\n col_nan_count = np.sum(np.isnan(self.X),axis=0)\n \n # Indexes of columns with at least 1 missing value sorted from most to least missing values\n col_nan_count_sorted = sorted(enumerate(col_nan_count),key=lambda x: x[1], reverse=True)\n col_ix_sorted = [tup[0] for tup in col_nan_count_sorted if tup[1]>0]\n\n tot_nan = sum(np.sum(np.isnan(self.X),axis=0))\n \n # for each column with missing values, sorted from most missing values to least..\n for i in col_ix_sorted:\n target = self.X[:,i].reshape(-1,1) # feature to fill missing values for\n features = np.delete(self.X, i, axis=1) # features used to predict missing values\n \n # scale features so that each has equal sway in KNN classification\n scaler = StandardScaler()\n features = scaler.fit_transform(features)\n \n # seperate missing values (to be predicted) and existing values (used to train classifier)\n target_train = target[[not na for na in np.isnan(target)]]\n target_missing = target[np.isnan(target)]\n \n # isolate observations with corresponding target values for training\n features_train = features[[not na for na in np.isnan(target).flatten()]]\n # temporarily fill in missing values in observation features used to train imputer\n mean_imputer = SimpleImputer(strategy='most_frequent')\n features_train = mean_imputer.fit_transform(features_train)\n \n # isolate feature observations with no corresponding target feature for prediction\n features_missing = features[np.isnan(target).flatten()]\n features_missing = mean_imputer.fit_transform(features_missing)\n \n # train model and store it in mode list corresponding to feature index\n self.model_list[i] = self.model.fit(features_train, target_train)\n\n in_sample_acc = self.model_list[i].score(features_train, target_train)\n #if False:\n # print(f\"Column {i} - filled {col_nan_count[i]} NaN values - in sample accuracy: {in_sample_acc}\")\n \n # predict in missing values\n predictions_missing = self.model.predict(features_missing)\n # fill missing values in with predictions\n target[np.isnan(target)] = predictions_missing\n self.X[:,i] = target.flatten()\n \n # for each column without missing values \n non_na_col_ix = set(range(0,self.X.shape[1])).difference(col_ix_sorted)\n #train model to predict the column features using other features. No missing values to fill in.\n for i in non_na_col_ix:\n target = self.X[:,i].reshape(-1,1)\n features = np.delete(self.X, i, axis=1)\n \n self.model_list[i] = self.model.fit(features, target)\n \n def fit_transform(self, X, verbose = 0):\n X_backup = copy.deepcopy(X)\n \n self.fit(X, verbose = verbose)\n assert sum(sum(np.isnan(X))) == sum(sum(np.isnan(X_backup)))\n return self.X\n\n def transform(self, X):\n self.X = copy.deepcopy(X)\n col_nan_count = np.sum(np.isnan(X),axis=0)\n col_ixs = [i for i, count in enumerate(col_nan_count) if count>0]\n\n for i in col_ixs:\n target = self.X[:,i].reshape(-1,1)\n features = np.delete(self.X, i, axis=1)\n features_missing = features[np.isnan(target).flatten()]\n if len(features_missing.shape)==1:\n features_missing = features_missing.reshape(-1,1)\n features_missing = mean_imputer.fit_transform(features_missing)\n\n predictions_missing = self.model_list[i].predict(features_missing)\n\n target[np.isnan(target)] = predictions_missing\n \n # Replace features \n self.X[:,i] = target.flatten()\n\n return self.X",
"_____no_output_____"
]
],
[
[
"### Preprocessing",
"_____no_output_____"
]
],
[
[
"from sklearn.feature_extraction.text import CountVectorizer\nfrom sklearn.base import BaseEstimator, TransformerMixin\n\ndef col_ix(label):\n col_list = ['sex','married','age','education','occupation',\n 'time_in_area','dual_income','num_people_household',\n 'num_children_household','home_status','home_type','ethnicity',\n 'language']\n\n return col_list.index(label)\n\n# Artificial predictor to satisfy Pipeline's requirement that the last class needs to be an estimator \n# (able to take a Y parameter)\nclass LastEstimator():\n def __init__(self):\n self.encoder=None\n def fit(self,X,Y=None):\n return self\n def transform(self, X, Y=None):\n return X\n def fit_transform(self, X, Y=None):\n #print(\"LastEstimator.fit_transform\")\n return X\n\n# Class to convert 0 dimensional NP arrays to 1 dimensional NP arrays for compatibility \nclass reshaper(BaseEstimator, TransformerMixin):\n def __init__(self):\n self.x = 0\n\n def fit(self, X=None, Y=None):\n return self\n\n def transform(self, X, Y=None):\n if type(X) is pd.Series:\n X=X.values\n return X.reshape(-1, 1)\n\n# Class to convert sparse scipy arrays NP arrays for compatibility \nclass ToDenseArray():\n def __init__(self):\n None\n def fit(self, X, Y=None):\n return self\n def transform(self, X, Y=None):\n return X.toarray()\n\n# Define pipeline to preprocess numeric features:\n # age, time_in_area, num_people_household, num_child_household\nnumeric_pipeline = Pipeline([\n ('reshape', reshaper()),\n ('scale', MinMaxScaler()),\n ('deskew',PowerTransformer()),\n ('predict',LastEstimator())\n ]) # scale and deskew each numeric feature\n\n# Define pipeline to preprocess binary features:\n # sex, married\nbinary_pipeline = Pipeline([\n ('reshape', reshaper()),\n ('OHE', OneHotEncoder(handle_unknown='ignore')),\n ('to_dense',ToDenseArray()),\n ('predict',LastEstimator())\n]) # # Make dummy variables for both possible values of each binary feature\n\n# Define pipeline to preprocess numeric features:\n # dual_income, education, occupation, home_status, home_type, ethnicity, language\ncategorical_pipeline = Pipeline([\n ('reshape', reshaper()),\n ('OHE', OneHotEncoder(handle_unknown='ignore')),\n ('to_dense',ToDenseArray()),\n ('predict',LastEstimator())\n]) # Make dummy variables for each possible value of each categorical feature\n\n# define columnransformer to apply preprocessing steps to each feature\nct = ColumnTransformer([\n ('sex', binary_pipeline, col_ix('sex')),\n ('married', binary_pipeline, col_ix('married')),\n ('dual_income', categorical_pipeline, col_ix('dual_income')),\n ('education', categorical_pipeline, col_ix('education')),\n ('occupation', categorical_pipeline, col_ix('occupation')),\n ('home_status', categorical_pipeline, col_ix('home_status')),\n ('home_type', categorical_pipeline, col_ix('home_type')),\n ('ethnicicty', categorical_pipeline, col_ix('ethnicity')),\n ('language', categorical_pipeline, col_ix('language')),\n ('age', numeric_pipeline, col_ix('age')),\n ('time_in_area', numeric_pipeline, col_ix('time_in_area')),\n ('num_people_household', numeric_pipeline, col_ix('num_people_household')),\n ('num_children_household', numeric_pipeline, col_ix('num_children_household')), \n ])",
"_____no_output_____"
],
[
"def report_metrics(pipeline_gridsearch):\n estimator = pipeline_gridsearch.best_estimator_\n \n best_params = estimator.named_steps['clf'].best_params_\n best_score_cv = pipeline_gridsearch.best_score_\n score_std = pipeline_gridsearch.cv_results_['std_test_score'][pipeline_gridsearch.best_index_]\n train_score = accuracy_score(estimator.predict(x_train), y_train)\n test_score = accuracy_score(estimator.predict(x_test), y_test)\n \n estimator.fit(x_train, y_train)\n test_score_refit = accuracy_score(estimator.predict(x_test), y_test)\n\n print('{:<40}: {:<50}'.format('Best parameters', repr(best_params)))\n print('{:<40}: {:<50}'.format('Best validation score', '{} +-{}'.format(round(best_score_cv,3),round(score_std,3))))\n print('{:<40}: {:<50}'.format('Train score', round(train_score,3)))\n print('{:<40}: {:<50}'.format('Test score', round(test_score,3)))\n print('{:<40}: {:<50}'.format('Test score (all training data)', test_score_refit))",
"_____no_output_____"
]
],
[
[
"# Classification",
"_____no_output_____"
],
[
"### 1. K-Nearest-Neighbors Classifier",
"_____no_output_____"
]
],
[
[
"# Try odd values between 5 and 29 for N\nKNN_param_grid = {\n 'n_neighbors': [x*2+1 for x in range(2,14)]\n}\n\nKNN_gridsearch = GridSearchCV(KNeighborsClassifier(), KNN_param_grid, cv=3, n_jobs=-1)\n\nKNN_pipeline = Pipeline([\n ('impute', KNNImputer()),\n ('preprocess', ct),\n ('clf', KNN_gridsearch)\n ])\n\nKNN_pipeline_gridsearch = GridSearchCV(KNN_pipeline, param_grid={}, cv=3, n_jobs=-1)\n\nKNN_pipeline_gridsearch.fit(x_train, y_train)",
"_____no_output_____"
],
[
"print(\"{:^60}\".format(\"KNN CLASSIFIER RESULTS\"))\nreport_metrics(KNN_pipeline_gridsearch)",
" KNN CLASSIFIER RESULTS \nBest parameters : {'n_neighbors': 23} \nBest validation score : 0.324 +-0.007 \nTrain score : 0.394 \nTest score : 0.326 \nTest score (all training data) : 0.3257365202890495 \n"
]
],
[
[
"### 2a. Logistic Regression - No Regularization",
"_____no_output_____"
]
],
[
[
"LR_param_grid = {\n}\n\nLR_gridsearch = GridSearchCV(LogisticRegression(), LR_param_grid, cv=3, n_jobs=-1)\n\nLR_pipeline = Pipeline([\n ('impute', KNNImputer()),\n ('preprocess', ct),\n ('clf', LR_gridsearch)\n ])\n\nLR_pipeline_gridsearch = GridSearchCV(LR_pipeline, param_grid={}, cv=3, n_jobs=-1)\nLR_pipeline_gridsearch.fit(x_train,y_train)",
"_____no_output_____"
],
[
"print(\"{:^60}\".format(\"LOGISTIC REGRESSION RESULTS\"))\nreport_metrics(LR_pipeline_gridsearch)",
" LOGISTIC REGRESSION RESULTS \nBest parameters : {} \nBest validation score : 0.334 +-0.004 \nTrain score : 0.362 \nTest score : 0.342 \nTest score (all training data) : 0.3424124513618677 \n"
]
],
[
[
"### 2b. Logistic Regression - L1 Regularization",
"_____no_output_____"
]
],
[
[
"LR1_param_grid = {\n 'penalty': ['l1'],\n 'C':[12,11,10,9,8,7,6]\n}\n\nLR1_gridsearch = GridSearchCV(LogisticRegression(), LR1_param_grid, cv=3, n_jobs=-1)\n\nLR1_pipeline = Pipeline([\n ('impute', KNNImputer()),\n ('preprocess', ct),\n ('clf', LR1_gridsearch)\n ])\n\nLR1_pipeline_gridsearch = GridSearchCV(LR1_pipeline, param_grid={}, cv=3, n_jobs=-1)\nLR1_pipeline_gridsearch.fit(x_train,y_train)",
"_____no_output_____"
],
[
"print(\"{:^60}\".format(\"LOGISTIC REGRESSION (L1 PENALTY) RESULTS\"))\nreport_metrics(LR1_pipeline_gridsearch)",
" LOGISTIC REGRESSION (L1 PENALTY) RESULTS \nBest parameters : {'C': 9, 'penalty': 'l1'} \nBest validation score : 0.334 +-0.004 \nTrain score : 0.363 \nTest score : 0.34 \nTest score (all training data) : 0.33852140077821014 \n"
]
],
[
[
"### 2c. Logistic Regression - L2 Regularization",
"_____no_output_____"
]
],
[
[
"LR2_param_grid = {\n 'penalty': ['l2'],\n 'C':[10, 8, 6, 5, 4, 2]\n}\n\nLR2_gridsearch = GridSearchCV(LogisticRegression(), LR2_param_grid, cv=3, n_jobs=-1)\n\nLR2_pipeline = Pipeline([\n ('impute', KNNImputer()),\n ('preprocess', ct),\n ('clf', LR1_gridsearch)\n ])\n\nLR2_pipeline_gridsearch = GridSearchCV(LR2_pipeline, param_grid={}, cv=3, n_jobs=-1)\nLR2_pipeline_gridsearch.fit(x_train,y_train)",
"_____no_output_____"
],
[
"print(\"{:^60}\".format(\"LOGISTIC REGRESSION (L2 PENALTY) RESULTS\"))\nreport_metrics(LR2_pipeline_gridsearch)",
" LOGISTIC REGRESSION (L2 PENALTY) RESULTS \nBest parameters : {'C': 11, 'penalty': 'l1'} \nBest validation score : 0.335 +-0.004 \nTrain score : 0.363 \nTest score : 0.337 \nTest score (all training data) : 0.33740967204002226 \n"
]
],
[
[
"### 3. LogisticIT",
"_____no_output_____"
]
],
[
[
"LRIT_param_grid = {\n 'alpha':[0.05,0.075,0.1,0.2,0.3,0.4]\n}\n\nLRIT_gridsearch = GridSearchCV(LogisticIT(), LRIT_param_grid, cv=3, n_jobs=-1)\n\nLRIT_pipeline = Pipeline([\n ('impute', KNNImputer()),\n ('preprocess', ct),\n ('clf', LRIT_gridsearch)\n ])\n\nLRIT_pipeline_gridsearch = GridSearchCV(LRIT_pipeline, param_grid={}, cv=3, n_jobs=-1)\nLRIT_pipeline_gridsearch.fit(x_train,y_train)",
"_____no_output_____"
],
[
"print(\"{:^60}\".format(\"ORDINAL LOGISTIC (IMMEDIATE THRESHOLD) RESULTS\"))\nreport_metrics(LRIT_pipeline_gridsearch)",
" ORDINAL LOGISTIC (IMMEDIATE THRESHOLD) RESULTS \nBest parameters : {'alpha': 0.05} \nBest validation score : 0.325 +-0.006 \nTrain score : 0.327 \nTest score : 0.32 \nTest score (all training data) : 0.32017787659811003 \n"
]
],
[
[
"### 4. Random Forest Classifier",
"_____no_output_____"
]
],
[
[
"RF_param_grid = {\n 'n_estimators': [x*100 for x in range(1,10)]\n}\n\nRF_gridsearch = GridSearchCV(RandomForestClassifier(), RF_param_grid, cv=3, n_jobs=-1)\n\nRF_pipeline = Pipeline([\n ('impute', KNNImputer()),\n ('preprocess', ct),\n ('clf', RF_gridsearch)\n ])\n\nRF_pipeline_gridsearch = GridSearchCV(RF_pipeline, param_grid={}, cv=3, n_jobs=-1)\nRF_pipeline_gridsearch.fit(x_train,y_train)",
"_____no_output_____"
],
[
"print(\"{:^60}\".format(\"RANDOM FOREST RESULTS\"))\nreport_metrics(RF_pipeline_gridsearch)",
" RANDOM FOREST RESULTS \nBest parameters : {'n_estimators': 200} \nBest validation score : 0.317 +-0.008 \nTrain score : 0.87 \nTest score : 0.31 \nTest score (all training data) : 0.31017231795441913 \n"
],
[
"from xgboost.sklearn import XGBClassifier\n\nXGBC1_param_grid = {\n 'learning_rate':[0.1],\n 'n_estimators':[1000],\n 'max_depth':[5],\n 'min_child_weight':[1],\n 'gamma':[0],\n 'subsample':[0.8],\n 'colsample_bytree':[0.8],\n 'scale_pos_weight':[1],\n 'max_depth': range(3,10,2),\n 'min_child_weight': range(1,6,2)\n}\n\nXGBC1_gridsearch = GridSearchCV(XGBClassifier(), XGBC1_param_grid, cv=3, n_jobs=-1)\n\nXGBC1_pipeline = Pipeline([\n ('impute', KNNImputer()),\n ('preprocess', ct),\n ('clf', XGBC1_gridsearch)\n ])\n\nXGBC1_pipeline_gridsearch = GridSearchCV(XGBC1_pipeline, param_grid={}, cv=3, n_jobs=-1)\nXGBC1_pipeline_gridsearch.fit(x_train,y_train)",
"_____no_output_____"
],
[
"print(\"{:^60}\".format(\"BOOSTED FOREST CLASSIFIER #1 RESULTS\"))\nreport_metrics(XGBC1_pipeline_gridsearch)",
" BOOSTED FOREST CLASSIFIER #1 RESULTS \nBest parameters : {'colsample_bytree': 0.8, 'gamma': 0, 'learning_rate': 0.1, 'max_depth': 3, 'min_child_weight': 3, 'n_estimators': 1000, 'scale_pos_weight': 1, 'subsample': 0.8}\nBest validation score : 0.329 +-0.007 \nTrain score : 0.557 \nTest score : 0.338 \nTest score (all training data) : 0.3379655364091162 \n"
]
]
] | [
"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"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
]
] |
ecea6abc41fe95a0740e80d80b4d27de6f532585 | 3,491 | ipynb | Jupyter Notebook | diffprog/julia_dp/repository/tf2_2-Copy1.2.ipynb | jskDr/keraspp_2021 | dc46ebb4f4dea48612135136c9837da7c246534a | [
"MIT"
] | 4 | 2021-09-21T15:35:04.000Z | 2021-12-14T12:14:44.000Z | diffprog/julia_dp/repository/tf2_2-Copy1.2.ipynb | jskDr/keraspp_2021 | dc46ebb4f4dea48612135136c9837da7c246534a | [
"MIT"
] | null | null | null | diffprog/julia_dp/repository/tf2_2-Copy1.2.ipynb | jskDr/keraspp_2021 | dc46ebb4f4dea48612135136c9837da7c246534a | [
"MIT"
] | null | null | null | 21.549383 | 68 | 0.454025 | [
[
[
"## Math based differentiation",
"_____no_output_____"
]
],
[
[
"f = lambda x, n: x**n \ndf_th = lambda x, n: n*f(x,n-1)\n\ndef df_ad(x, n):\n x_tf = tf.Variable(x)\n with tf.GradientTape() as tape:\n y = f(x_tf,n)\n return tape.gradient(y, x_tf)\n\nx = float(2.0)\nprint(\"f(x,10) = 2^10 = \", f(x,10))\nprint(\"Theory: df(x,10)/dx = 10 x 2^9 = \", df_th(x,10))\nprint(\"AD: df(x,10) = \", df_ad(x,10))",
"f(x,10) = 2^10 = 1024.0\nTheory: df(x,10)/dx = 10 x 2^9 = 5120.0\nAD: df(x,10) = tf.Tensor(5120.0, shape=(), dtype=float32)\n"
],
[
"x_all = np.random.randn(1000)\n%time y_all = list(map(lambda x: df_ad(x,10), x_all))",
"CPU times: user 511 ms, sys: 2.65 ms, total: 514 ms\nWall time: 514 ms\n"
]
],
[
[
"## Code based differentiation",
"_____no_output_____"
]
],
[
[
"def f(x,n): \n r = 1\n for m in range(n):\n r *= x\n return r\ndf_th = lambda x, n: n*f(x,n-1)\n\ndef df_ad(x, n):\n x_tf = tf.Variable(x)\n with tf.GradientTape() as tape:\n y = f(x_tf,n)\n return tape.gradient(y, x_tf)\n\nx = float(2.0)\nprint(\"f(x,10) = 2^10 = \", f(x,10))\nprint(\"Theory: df(x,10)/dx = 10 x 2^9 = \", df_th(x,10))\nprint(\"AD: df(x,10) = \", df_ad(x,10))",
"f(x,10) = 2^10 = 1024.0\nTheory: df(x,10)/dx = 10 x 2^9 = 5120.0\nAD: df(x,10) = tf.Tensor(5120.0, shape=(), dtype=float32)\n"
],
[
"x_all = np.random.randn(1000)\n%time y_all = list(map(lambda x: df_ad(x,10), x_all))\nlen(y_all)",
"CPU times: user 2.24 s, sys: 5.18 ms, total: 2.25 s\nWall time: 2.25 s\n"
]
]
] | [
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
]
] |
ecea6efd439a806c70ede3438ca7043005888d28 | 5,531 | ipynb | Jupyter Notebook | 1-tutorials/1-getting-started.ipynb | anitagraser/movingpandas-examples | 093d87a89f197f322f250d0a308cc8e07b55b525 | [
"BSD-3-Clause"
] | 77 | 2020-10-11T20:45:19.000Z | 2022-03-29T16:06:58.000Z | 1-tutorials/1-getting-started.ipynb | anitagraser/movingpandas-examples | 093d87a89f197f322f250d0a308cc8e07b55b525 | [
"BSD-3-Clause"
] | 8 | 2021-01-20T15:33:44.000Z | 2022-03-24T18:44:18.000Z | 1-tutorials/1-getting-started.ipynb | anitagraser/movingpandas-examples | 093d87a89f197f322f250d0a308cc8e07b55b525 | [
"BSD-3-Clause"
] | 18 | 2021-02-07T14:54:04.000Z | 2022-03-29T16:06:52.000Z | 24.473451 | 252 | 0.578919 | [
[
[
"# Getting started with MovingPandas\n\n<img align=\"right\" src=\"https://anitagraser.github.io/movingpandas/pics/movingpandas.png\">\n\n[](https://mybinder.org/v2/gh/anitagraser/movingpandas-examples/main?filepath=1-tutorials/1-getting-started.ipynb)\n\nMovingPandas provides a trajectory datatype based on GeoPandas.\nThe project home is at https://github.com/anitagraser/movingpandas\n\nThe documentation is available at https://movingpandas.readthedocs.io/en/master/",
"_____no_output_____"
]
],
[
[
"import pandas as pd\nimport geopandas as gpd\nfrom geopandas import GeoDataFrame, read_file\nfrom shapely.geometry import Point, LineString, Polygon\nfrom datetime import datetime, timedelta\nimport movingpandas as mpd\n\nprint(mpd.__version__)",
"_____no_output_____"
]
],
[
[
"## Creating a trajectory from scratch\n\nTrajectory objects consist of a trajectory ID and a GeoPandas GeoDataFrame with a DatetimeIndex. The data frame therefore represents the trajectory data as a Pandas time series with associated point locations (and optional further attributes).\n\nLet's create a small toy trajectory to see how this works:",
"_____no_output_____"
]
],
[
[
"df = pd.DataFrame([\n {'geometry':Point(0,0), 't':datetime(2018,1,1,12,0,0)},\n {'geometry':Point(6,0), 't':datetime(2018,1,1,12,6,0)},\n {'geometry':Point(6,6), 't':datetime(2018,1,1,12,10,0)},\n {'geometry':Point(9,9), 't':datetime(2018,1,1,12,15,0)}\n]).set_index('t')\ngdf = GeoDataFrame(df, crs=31256)\ntoy_traj = mpd.Trajectory(gdf, 1)\ntoy_traj",
"_____no_output_____"
],
[
"toy_traj.plot()",
"_____no_output_____"
]
],
[
[
"We can also access the trajectory's GeoDataFrame:",
"_____no_output_____"
]
],
[
[
"toy_traj.df",
"_____no_output_____"
],
[
"toy_traj.df.plot()",
"_____no_output_____"
]
],
[
[
"## Loading trajectory data from a GeoPackage\n\nThe MovingPandas repository contains a demo GeoPackage file that can be loaded as follows:",
"_____no_output_____"
]
],
[
[
"%%time\ngdf = read_file('../data/geolife_small.gpkg')\ngdf['t'] = pd.to_datetime(gdf['t'])\ngdf = gdf.set_index('t').tz_localize(None)\nprint(\"Finished reading {} rows\".format(len(df)))",
"_____no_output_____"
]
],
[
[
"After reading the trajectory point data from file, we want to construct the trajectories.",
"_____no_output_____"
],
[
"### Creating trajectories with TrajectoryCollection\n\nTrajectoryCollection is a convenience class that takes care of creating trajectories from a GeoDataFrame:",
"_____no_output_____"
]
],
[
[
"traj_collection = mpd.TrajectoryCollection(gdf, 'trajectory_id')\nprint(traj_collection)",
"_____no_output_____"
],
[
"traj_collection.plot(column='trajectory_id', legend=True, figsize=(9,5))",
"_____no_output_____"
]
],
[
[
"### Accessing individual trajectories",
"_____no_output_____"
]
],
[
[
"my_traj = traj_collection.trajectories[1]\nprint(my_traj)",
"_____no_output_____"
],
[
"my_traj.plot(linewidth=5, capstyle='round', figsize=(9,3))",
"_____no_output_____"
]
],
[
[
"To visualize trajectories in their geographical context, we can also create interactive plots with basemaps:",
"_____no_output_____"
]
],
[
[
"my_traj.hvplot(width=500, height=300, line_width=7.0, tiles='StamenTonerBackground')",
"_____no_output_____"
]
]
] | [
"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",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
]
] |
ecea73d14c11330327b0ad3d22eea8c702506053 | 1,015,013 | ipynb | Jupyter Notebook | .ipynb_checkpoints/Baseball_Stats-checkpoint.ipynb | bibinmjose/baseball_d3 | d104e640cf84f0069eeb81ff2fe0c964b8118d64 | [
"MIT"
] | null | null | null | .ipynb_checkpoints/Baseball_Stats-checkpoint.ipynb | bibinmjose/baseball_d3 | d104e640cf84f0069eeb81ff2fe0c964b8118d64 | [
"MIT"
] | null | null | null | .ipynb_checkpoints/Baseball_Stats-checkpoint.ipynb | bibinmjose/baseball_d3 | d104e640cf84f0069eeb81ff2fe0c964b8118d64 | [
"MIT"
] | null | null | null | 648.985294 | 209,166 | 0.93091 | [
[
[
"# Dataset Exploration\n\nThe dataset contains career statistics of baseball players. Each dataum has the name of player(`name`), `handednes`(**L** for Left and **R** for Right), `height` (in inchs) amd `weight` (in lbs), `avg`(Career average) and `HR` (Total Home runs). Body metrics include `height` and `weight` while perfomance is given by `HR` and `avg`.\n\n## Questions to explore:\n* Is there a correlation between body metrics and performance(avg or HR)?\n* Can you identify high avg/HR players from body metrics ? \n",
"_____no_output_____"
],
[
"# Data loading and summary",
"_____no_output_____"
]
],
[
[
"import csv\nimport pandas as pd\nimport numpy as np\nimport seaborn as sns\nimport matplotlib.pyplot as plt\nplt.style.use('ggplot')",
"_____no_output_____"
],
[
"baseball_lst=[]\nwith open(\"baseball_data.csv\") as f:\n records = csv.DictReader(f)\n for row in records:\n baseball_lst.append(row)\nbaseball = pd.read_csv('baseball_data.csv')\n\n# Checking for missing values in each column\nfor key in baseball.keys():\n if baseball[key].isnull().sum():\n print (key)",
"_____no_output_____"
],
[
"baseball.head(5)\n# 'HR' is home runs",
"_____no_output_____"
],
[
"baseball.describe()",
"_____no_output_____"
],
[
"# Players with top 5 averages\nbaseball.sort_values(by ='avg', ascending=False)[0:5]",
"_____no_output_____"
],
[
"# top 5 Home Run getters\nbaseball.sort_values(by ='HR', ascending=False)[0:5]",
"_____no_output_____"
],
[
"# Players with top 5 weights\nbaseball.sort_values(by ='weight', ascending=False)[0:5]",
"_____no_output_____"
]
],
[
[
"# Univariate Exploration and grid plots\n\nHeight in inchs and Weight in lbs.",
"_____no_output_____"
]
],
[
[
"# Histograms of columns.\nfig = plt.figure(figsize=(8,5))\nfor i,key in enumerate(baseball.keys()[2:]):\n ax = fig.add_subplot(2,2,i+1)\n ax.set_title(key)\n baseball[key].hist(bins=10)\nplt.tight_layout()\nplt.show()",
"_____no_output_____"
],
[
"# count of players based on handedness\nbaseball['handedness'].value_counts().plot.barh()\nplt.show()",
"_____no_output_____"
],
[
"bball_B = baseball[baseball['handedness']=='B']\nbball_R = baseball[baseball['handedness']=='R']\nbball_L = baseball[baseball['handedness']=='L']\n# plt.show()",
"_____no_output_____"
]
],
[
[
"# Paired Plots and Bivariate Exploration of dataset",
"_____no_output_____"
]
],
[
[
"# Paired Plots\n# baseball[(baseball[\"avg\"]==0)&(baseball[\"HR\"]==0)]\ng = sns.PairGrid(baseball)\ng = g.map_diag(plt.hist)\ng = g.map_offdiag(plt.scatter)\nplt.show()",
"_____no_output_____"
],
[
"# Paired Plots by group\ng = sns.PairGrid(baseball, hue = \"handedness\", palette='husl')\ng = g.map_diag(plt.hist,histtype=\"step\", linewidth=1)\ng = g.map_offdiag(plt.scatter)\nplt.legend()\nplt.show()",
"_____no_output_____"
]
],
[
[
"\n## Based on `Handedness`\n\nMedian `Height` and `weight` do not vary significantly based on handedness of the player. `avg` and `HR` is slightly higher for Left handed players.\n\n### Height",
"_____no_output_____"
]
],
[
[
"# Height based on handedness\nsns.boxplot(y = 'height', x='handedness', data = baseball)\nsns.stripplot(y = 'height', x='handedness', data = baseball, color='gray', jitter=True)\nplt.show()",
"_____no_output_____"
]
],
[
[
"### Weight",
"_____no_output_____"
]
],
[
[
"# Weight based on handedness\nplt.figure()\nsns.boxplot(y = 'weight', x='handedness', data = baseball)\nplt.show()",
"_____no_output_____"
]
],
[
[
"### Avg",
"_____no_output_____"
]
],
[
[
"# avg based on handedness\nsns.boxplot(y = 'avg', x='handedness', data = baseball)\nplt.show()",
"_____no_output_____"
],
[
"# avg based on handedness with avg>0\nsns.lvplot(y = 'avg', x='handedness', data = baseball[baseball['avg']!=0])\nplt.show()",
"_____no_output_____"
]
],
[
[
"### HR",
"_____no_output_____"
]
],
[
[
"# HR based on handedness\nplt.figure()\nsns.boxplot(y = 'HR', x='handedness', data = baseball)\nplt.show()",
"_____no_output_____"
],
[
"# HR based on handedness with HR >0\nplt.figure()\nsns.lvplot(y = 'HR', x='handedness', \\\n data = baseball[baseball['HR']!=0])\nplt.show()",
"_____no_output_____"
],
[
"bball_median=baseball.groupby('handedness').median()\nbball_median[\"Count\"]=baseball.groupby('handedness')[\"name\"].count()",
"_____no_output_____"
],
[
"bball_median.to_csv(\"baseball_median.csv\")\nbball_median",
"_____no_output_____"
]
],
[
[
"## Based on `weight`\n\nExploring the difference in average and home run based on three levels of weight - Low(`L`) Medium(`M`) and High(`H`).",
"_____no_output_____"
]
],
[
[
"pd.qcut(baseball['weight'], q=3, labels=['Low','Medium','High'])\\\n .cat.reorder_categories(['Low','Medium','High'],ordered=True)\\\n .value_counts()",
"_____no_output_____"
],
[
"# Defining a new dataframe with height and weight categorized\nbaseball_new = baseball.copy(deep=True)\nbaseball_new['weight_cat'] = \\\n pd.qcut(baseball_new['weight'], q=3, labels=['Low','Medium','High'])\\\n .cat.reorder_categories(['Low','Medium','High'],ordered=True)\nbaseball_new['height_cat'] = \\\n pd.qcut(baseball_new['height'], q=3, labels=['Low','Medium','High'])\\\n .cat.reorder_categories(['Low','Medium','High'],ordered=True)\nbaseball_new.head(5)",
"_____no_output_____"
],
[
"# Mean avg based on weight category\nbaseball_new.groupby('height_cat').mean()[['avg']].plot(kind='bar')\nplt.show()",
"_____no_output_____"
],
[
"# Mean HR based on weight category\nbaseball_new.groupby('weight_cat').mean()[['HR']].plot(kind='bar')\nplt.show()",
"_____no_output_____"
],
[
"# Paired Plots by group\ng = sns.PairGrid(baseball_new, hue = \"weight_cat\")\ng = g.map_diag(plt.hist,bins=20)\ng = g.map_offdiag(plt.scatter,alpha=0.4)\n# g = g.map_lower(plt.hexbin,gridsize=100)\nplt.legend()\nplt.show()",
"_____no_output_____"
],
[
"# Seperating into 10 Categories\nbaseball_new['weight_10cat'] = pd.qcut(baseball['weight'], q=10)\nbaseball_new.groupby('weight_10cat').median()[['HR']].plot(kind='bar')\nplt.show()\nbaseball_new.groupby('weight_10cat').median()[['avg']].plot(kind='bar')\nplt.show()",
"_____no_output_____"
]
],
[
[
"### `HR` vs. `avg` filtered by `weight_cat`",
"_____no_output_____"
]
],
[
[
"print(baseball_new.groupby('weight_cat').median())\nbaseball_new.groupby('weight_cat').mean().plot(x='avg',y='HR',kind='scatter', legend=True)\nplt.show()",
" height weight avg HR\nweight_cat \nLow 71.0 170.0 0.2440 13.0\nMedium 73.0 185.0 0.2365 17.0\nHigh 74.0 200.0 0.2270 19.5\n"
]
],
[
[
"## Based on `height`",
"_____no_output_____"
]
],
[
[
"bb_height_avg",
"_____no_output_____"
],
[
"baseball_new.groupby('height_cat').mean().plot(x='avg',y='HR',\\\n c='height',kind='scatter', legend=True)\nplt.show()",
"_____no_output_____"
],
[
"# Paired Plots by group\ng = sns.PairGrid(baseball_new, hue = \"height_cat\")\ng = g.map_diag(plt.hist,bins=20)\ng = g.map_offdiag(plt.scatter,alpha=0.4)\nplt.legend()\nplt.show()",
"_____no_output_____"
]
],
[
[
"## Home Run vs. Average",
"_____no_output_____"
]
],
[
[
"def plot_bball_cat(bball,_cat):\n COLORMAP ='rgbyo'\n for i,l in enumerate([\"Low\",\"Medium\",\"High\"]):\n d=bball[bball[_cat]==l]\n# print(bball)\n plt.scatter(x = d[\"avg\"],y=d[\"HR\"],alpha=0.4, label = l, color = COLORMAP[i])\n plt.scatter(x = d[\"avg\"].median(),y=d[\"HR\"].median(),s=5000,\\\n color = COLORMAP[i], marker ='s')\n \n plt.xlabel(\"Average\")\n plt.ylabel(\"Home Runs\")\n plt.legend()\n plt.show()\nplot_bball_cat(baseball_new,'height_cat')",
"_____no_output_____"
],
[
"plot_bball_cat(baseball_new,'weight_cat')",
"_____no_output_____"
]
],
[
[
"## Dumping Data Frame to csv",
"_____no_output_____"
]
],
[
[
"baseball_new.to_csv('baseball_data_modified')",
"_____no_output_____"
],
[
"baseball_new['height_10cat'] = pd.qcut(baseball['height'], q=5)\nbaseball_new.groupby('height_10cat').mean()[['HR']].plot(kind='bar')\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",
"code"
] | [
[
"markdown",
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
]
] |
ecea78c8b25c732708fd9d0df67194de54612b96 | 1,187 | ipynb | Jupyter Notebook | 3. Functions exercise.ipynb | muticodes/Python-for-DS-and-ML | d7289bb2d82df1cdcd5188e4e5ba8fd08de6f08e | [
"MIT"
] | null | null | null | 3. Functions exercise.ipynb | muticodes/Python-for-DS-and-ML | d7289bb2d82df1cdcd5188e4e5ba8fd08de6f08e | [
"MIT"
] | null | null | null | 3. Functions exercise.ipynb | muticodes/Python-for-DS-and-ML | d7289bb2d82df1cdcd5188e4e5ba8fd08de6f08e | [
"MIT"
] | null | null | null | 20.465517 | 177 | 0.526537 | [
[
[
"## LESSER OF TWO EVENS: Write a function that returns the lesser of two given numbers *if* both numbers are even, but returns the greater if one or both numbers are odd ##",
"_____no_output_____"
]
],
[
[
"def lesser_of_two_evens (arg1,arg2):\n if arg1%2 == 0 and arg2%2 == 0:\n print (min(arg1,arg2))\n else: \n print (max(arg1,arg2))",
"_____no_output_____"
]
]
] | [
"markdown",
"code"
] | [
[
"markdown"
],
[
"code"
]
] |
ecea80eef150cffd5ad12bc40dcd0fdb44fc1640 | 37,853 | ipynb | Jupyter Notebook | notebooks/3-fundamentals/PY0101EN-3-1-Conditions.ipynb | raphtrajano/introduction-to-python | be9b1f4cfea185ddad26686804b7607b9e12b7a4 | [
"MIT"
] | 8 | 2020-04-02T02:10:47.000Z | 2021-09-08T11:50:53.000Z | notebooks/3-fundamentals/PY0101EN-3-1-Conditions.ipynb | raphtrajano/introduction-to-python | be9b1f4cfea185ddad26686804b7607b9e12b7a4 | [
"MIT"
] | null | null | null | notebooks/3-fundamentals/PY0101EN-3-1-Conditions.ipynb | raphtrajano/introduction-to-python | be9b1f4cfea185ddad26686804b7607b9e12b7a4 | [
"MIT"
] | 19 | 2020-01-16T18:33:42.000Z | 2022-02-15T22:24:45.000Z | 30.749797 | 771 | 0.50638 | [
[
[
"<a href=\"https://cognitiveclass.ai/\">\n <img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Ad/CCLog.png\" width=\"200\" align=\"center\">\n</a>",
"_____no_output_____"
],
[
"<h1>Conditions in Python</h1>",
"_____no_output_____"
],
[
"<p><strong>Welcome!</strong> This notebook will teach you about the condition statements in the Python Programming Language. By the end of this lab, you'll know how to use the condition statements in Python, including operators, and branching.</p>",
"_____no_output_____"
],
[
"<h2>Table of Contents</h2>\n<div class=\"alert alert-block alert-info\" style=\"margin-top: 20px\">\n <ul>\n <li>\n <a href=\"#cond\">Condition Statements</a>\n <ul>\n <li><a href=\"comp\">Comparison Operators</a></li>\n <li><a href=\"branch\">Branching</a></li>\n <li><a href=\"logic\">Logical operators</a></li>\n </ul>\n </li>\n <li>\n <a href=\"#quiz\">Quiz on Condition Statement</a>\n </li>\n </ul>\n <p>\n Estimated time needed: <strong>20 min</strong>\n </p>\n</div>\n\n<hr>",
"_____no_output_____"
],
[
"<h2 id=\"cond\">Condition Statements</h2>",
"_____no_output_____"
],
[
"<h3 id=\"comp\">Comparison Operators</h3>",
"_____no_output_____"
],
[
"Comparison operations compare some value or operand and, based on a condition, they produce a Boolean. When comparing two values you can use these operators:\n\n<ul>\n <li>equal: <b>==</b></li>\n <li>not equal: <b>!=</b></li>\n <li>greater than: <b>></b></li>\n <li>less than: <b><</b></li>\n <li>greater than or equal to: <b>>=</b></li>\n <li>less than or equal to: <b><=</b></li>\n</ul>",
"_____no_output_____"
],
[
"Let's assign <code>a</code> a value of 5. Use the equality operator denoted with two equal <b>==</b> signs to determine if two values are equal. The case below compares the variable <code>a</code> with 6.",
"_____no_output_____"
]
],
[
[
"# Condition Equal\n\na = 5\na == 6",
"_____no_output_____"
]
],
[
[
"The result is <b>False</b>, as 5 does not equal to 6.",
"_____no_output_____"
],
[
"Consider the following equality comparison operator <code>i > 5</code>. If the value of the left operand, in this case the variable <b>i</b>, is greater than the value of the right operand, in this case 5, then the statement is <b>True</b>. Otherwise, the statement is <b>False</b>. If <b>i</b> is equal to 6, because 6 is larger than 5, the output is <b>True</b>.",
"_____no_output_____"
]
],
[
[
"# Greater than Sign\n\ni = 6\ni > 5",
"_____no_output_____"
]
],
[
[
"Set <code>i = 2</code>. The statement is false as 2 is not greater than 5:",
"_____no_output_____"
]
],
[
[
"# Greater than Sign\n\ni = 2\ni > 5",
"_____no_output_____"
]
],
[
[
" Let's display some values for <code>i</code> in the figure. Set the values greater than 5 in green and the rest in red. The green region represents where the condition is **True**, the red where the statement is **False**. If the value of <code>i</code> is 2, we get **False** as the 2 falls in the red region. Similarly, if the value for <code>i</code> is 6 we get a **True** as the condition falls in the green region. ",
"_____no_output_____"
],
[
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%203/Images/CondsGreater.gif\" width=\"650\" />",
"_____no_output_____"
],
[
"The inequality test uses an exclamation mark preceding the equal sign, if two operands are not equal then the condition becomes **True**. For example, the following condition will produce **True** as long as the value of <code>i</code> is not equal to 6:",
"_____no_output_____"
]
],
[
[
"# Inequality Sign\n\ni = 2\ni != 6",
"_____no_output_____"
]
],
[
[
"When <code>i</code> equals 6 the inequality expression produces <b>False</b>. ",
"_____no_output_____"
]
],
[
[
"# Inequality Sign\n\ni = 6\ni != 6",
"_____no_output_____"
]
],
[
[
"See the number line below. when the condition is **True** the corresponding numbers are marked in green and for where the condition is **False** the corresponding number is marked in red. If we set <code>i</code> equal to 2 the operator is true as 2 is in the green region. If we set <code>i</code> equal to 6, we get a **False** as the condition falls in the red region.",
"_____no_output_____"
],
[
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%203/Images/CondsIneq.gif\" width=\"650\" />",
"_____no_output_____"
],
[
" We can apply the same methods on strings. For example, use an equality operator on two different strings. As the strings are not equal, we get a **False**.",
"_____no_output_____"
]
],
[
[
"# Use Equality sign to compare the strings\n\n\"ACDC\" == \"Michael Jackson\"",
"_____no_output_____"
]
],
[
[
" If we use the inequality operator, the output is going to be **True** as the strings are not equal.",
"_____no_output_____"
]
],
[
[
"# Use Inequality sign to compare the strings\n\n\"ACDC\" != \"Michael Jackson\"",
"_____no_output_____"
]
],
[
[
"Inequality operation is also used to compare the letters/words/symbols according to the ASCII value of letters. The decimal value shown in the following table represents the order of the character:\n",
"_____no_output_____"
],
[
"For example, the ASCII code for <b>!</b> is 33, while the ASCII code for <b>+</b> is 43. Therefore <b>+</b> is larger than <b>!</b> as 43 is greater than 33.",
"_____no_output_____"
],
[
"Similarly, the value for <b>A</b> is 65, and the value for <b>B</b> is 66 therefore:",
"_____no_output_____"
]
],
[
[
"# Compare characters\n\n'B' > 'A'",
"_____no_output_____"
]
],
[
[
" When there are multiple letters, the first letter takes precedence in ordering:",
"_____no_output_____"
]
],
[
[
"# Compare characters\n\n'BA' > 'AB'",
"_____no_output_____"
]
],
[
[
"<b>Note</b>: Upper Case Letters have different ASCII code than Lower Case Letters, which means the comparison between the letters in python is case-sensitive.",
"_____no_output_____"
],
[
"<h3 id=\"branch\">Branching</h3>",
"_____no_output_____"
],
[
" Branching allows us to run different statements for different inputs. It is helpful to think of an **if statement** as a locked room, if the statement is **True** we can enter the room and your program will run some predefined tasks, but if the statement is **False** the program will ignore the task.\n",
"_____no_output_____"
],
[
"For example, consider the blue rectangle representing an ACDC concert. If the individual is older than 18, they can enter the ACDC concert. If they are 18 or younger than 18 they cannot enter the concert.\n\nUse the condition statements learned before as the conditions need to be checked in the **if statement**. The syntax is as simple as <code> if <i>condition statement</i> :</code>, which contains a word <code>if</code>, any condition statement, and a colon at the end. Start your tasks which need to be executed under this condition in a new line with an indent. The lines of code after the colon and with an indent will only be executed when the **if statement** is **True**. The tasks will end when the line of code does not contain the indent.\n\nIn the case below, the tasks executed <code>print(“you can enter”)</code> only occurs if the variable <code>age</code> is greater than 18 is a True case because this line of code has the indent. However, the execution of <code>print(“move on”)</code> will not be influenced by the if statement.",
"_____no_output_____"
]
],
[
[
"# If statement example\n\nage = 19\n#age = 18\n\n#expression that can be true or false\nif age > 18:\n \n #within an indent, we have the expression that is run if the condition is true\n print(\"you can enter\" )\n\n#The statements after the if statement will run regardless if the condition is true or false \nprint(\"move on\")",
"_____no_output_____"
]
],
[
[
"<i>Try uncommenting the age variable</i>",
"_____no_output_____"
],
[
"It is helpful to use the following diagram to illustrate the process. On the left side, we see what happens when the condition is <b>True</b>. The person enters the ACDC concert representing the code in the indent being executed; they then move on. On the right side, we see what happens when the condition is <b>False</b>; the person is not granted access, and the person moves on. In this case, the segment of code in the indent does not run, but the rest of the statements are run. ",
"_____no_output_____"
],
[
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%203/Images/CondsIf.gif\" width=\"650\" />",
"_____no_output_____"
],
[
"The <code>else</code> statement runs a block of code if none of the conditions are **True** before this <code>else</code> statement. Let's use the ACDC concert analogy again. If the user is 17 they cannot go to the ACDC concert, but they can go to the Meatloaf concert.\nThe syntax of the <code>else</code> statement is similar as the syntax of the <code>if</code> statement, as <code>else :</code>. Notice that, there is no condition statement for <code>else</code>.\nTry changing the values of <code>age</code> to see what happens: ",
"_____no_output_____"
]
],
[
[
"# Else statement example\n\nage = 18\n# age = 19\n\nif age > 18:\n print(\"you can enter\" )\nelse:\n print(\"go see Meat Loaf\" )\n \nprint(\"move on\")",
"_____no_output_____"
]
],
[
[
"The process is demonstrated below, where each of the possibilities is illustrated on each side of the image. On the left is the case where the age is 17, we set the variable age to 17, and this corresponds to the individual attending the Meatloaf concert. The right portion shows what happens when the individual is over 18, in this case 19, and the individual is granted access to the concert.",
"_____no_output_____"
],
[
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%203/Images/CondsElse.gif\" width=\"650\" />",
"_____no_output_____"
],
[
"The <code>elif</code> statement, short for else if, allows us to check additional conditions if the condition statements before it are <b>False</b>. If the condition for the <code>elif</code> statement is <b>True</b>, the alternate expressions will be run. Consider the concert example, where if the individual is 18 they will go to the Pink Floyd concert instead of attending the ACDC or Meat-loaf concert. The person of 18 years of age enters the area, and as they are not older than 18 they can not see ACDC, but as they are 18 years of age, they attend Pink Floyd. After seeing Pink Floyd, they move on. The syntax of the <code>elif</code> statement is similar in that we merely change the <code>if</code> in <code>if</code> statement to <code>elif</code>.",
"_____no_output_____"
]
],
[
[
"# Elif statment example\n\nage = 18\n\nif age > 18:\n print(\"you can enter\" )\nelif age == 18:\n print(\"go see Pink Floyd\")\nelse:\n print(\"go see Meat Loaf\" )\n \nprint(\"move on\")",
"_____no_output_____"
]
],
[
[
"The three combinations are shown in the figure below. The left-most region shows what happens when the individual is less than 18 years of age. The central component shows when the individual is exactly 18. The rightmost shows when the individual is over 18.",
"_____no_output_____"
],
[
"<img src =\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%203/Images/CondsElif.gif\" width=\"650\" />",
"_____no_output_____"
],
[
" Look at the following code:\n",
"_____no_output_____"
]
],
[
[
"# Condition statement example\n\nalbum_year = 1983\nalbum_year = 1970\n\nif album_year > 1980:\n print(\"Album year is greater than 1980\")\n \nprint('do something..')",
"_____no_output_____"
]
],
[
[
"Feel free to change <code>album_year</code> value to other values -- you'll see that the result changes!",
"_____no_output_____"
],
[
"Notice that the code in the above <b>indented</b> block will only be executed if the results are <b>True</b>. ",
"_____no_output_____"
],
[
"As before, we can add an <code>else</code> block to the <code>if</code> block. The code in the <code>else</code> block will only be executed if the result is <b>False</b>.\n\n\n<b>Syntax:</b> \n\nif (condition):\n # do something\nelse:\n # do something else",
"_____no_output_____"
],
[
"If the condition in the <code>if</code> statement is <b>False</b>, the statement after the <code>else</code> block will execute. This is demonstrated in the figure: ",
"_____no_output_____"
],
[
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%203/Images/CondsLogicMap.png\" width=\"650\" />",
"_____no_output_____"
]
],
[
[
"# Condition statement example\n\nalbum_year = 1983\n#album_year = 1970\n\nif album_year > 1980:\n print(\"Album year is greater than 1980\")\nelse:\n print(\"less than 1980\")\n\nprint('do something..')",
"_____no_output_____"
]
],
[
[
"Feel free to change the <code>album_year</code> value to other values -- you'll see that the result changes based on it!",
"_____no_output_____"
],
[
"<h3 id=\"logic\">Logical operators</h3>",
"_____no_output_____"
],
[
"\nSometimes you want to check more than one condition at once. For example, you might want to check if one condition and another condition is **True**. Logical operators allow you to combine or modify conditions.\n<ul>\n <li><code>and</code></li>\n <li><code>or</code></li>\n <li><code>not</code></li>\n</ul>\n\nThese operators are summarized for two variables using the following truth tables: ",
"_____no_output_____"
],
[
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%203/Images/CondsTable.png\" width=\"650\" />",
"_____no_output_____"
],
[
"The <code>and</code> statement is only **True** when both conditions are true. The <code>or</code> statement is true if one condition is **True**. The <code>not</code> statement outputs the opposite truth value.",
"_____no_output_____"
],
[
"Let's see how to determine if an album was released after 1979 (1979 is not included) and before 1990 (1990 is not included). The time periods between 1980 and 1989 satisfy this condition. This is demonstrated in the figure below. The green on lines <strong>a</strong> and <strong>b</strong> represents periods where the statement is **True**. The green on line <strong>c</strong> represents where both conditions are **True**, this corresponds to where the green regions overlap. \n\n",
"_____no_output_____"
],
[
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%203/Images/CondsEgOne.png\" width=\"650\" />",
"_____no_output_____"
],
[
" The block of code to perform this check is given by:",
"_____no_output_____"
]
],
[
[
"# Condition statement example\n\nalbum_year = 1980\n\nif(album_year > 1979) and (album_year < 1990):\n print (\"Album year was in between 1980 and 1989\")\n \nprint(\"\")\nprint(\"Do Stuff..\")",
"_____no_output_____"
]
],
[
[
"To determine if an album was released before 1980 (~ - 1979) or after 1989 (1990 - ~ ), an **or** statement can be used. Periods before 1980 (~ - 1979) or after 1989 (1990 - ~) satisfy this condition. This is demonstrated in the following figure, the color green in <strong>a</strong> and <strong>b</strong> represents periods where the statement is true. The color green in **c** represents where at least one of the conditions \nare true. \n",
"_____no_output_____"
],
[
"<img src=\"https://s3-api.us-geo.objectstorage.softlayer.net/cf-courses-data/CognitiveClass/PY0101EN/Chapter%203/Images/CondsEgTwo.png\" width=\"650\" />",
"_____no_output_____"
],
[
"The block of code to perform this check is given by:",
"_____no_output_____"
]
],
[
[
"# Condition statement example\n\nalbum_year = 1990\n\nif(album_year < 1980) or (album_year > 1989):\n print (\"Album was not made in the 1980's\")\nelse:\n print(\"The Album was made in the 1980's \")",
"_____no_output_____"
]
],
[
[
"The <code>not</code> statement checks if the statement is false:",
"_____no_output_____"
]
],
[
[
"# Condition statement example\n\nalbum_year = 1983\n\nif not (album_year == '1984'):\n print (\"Album year is not 1984\")",
"_____no_output_____"
]
],
[
[
"<hr>",
"_____no_output_____"
],
[
"<h2 id=\"quiz\">Quiz on Conditions</h2>",
"_____no_output_____"
],
[
"Write an if statement to determine if an album had a rating greater than 8. Test it using the rating for the album <b>“Back in Black”</b> that had a rating of 8.5. If the statement is true print \"This album is Amazing!\"",
"_____no_output_____"
]
],
[
[
"# Write your code below and press Shift+Enter to execute",
"This album is Amazing!\n"
]
],
[
[
"Double-click __here__ for the solution.\n\n<!-- \nrating = 8.5\nif rating > 8:\n print (\"This album is Amazing!\")\n -->",
"_____no_output_____"
],
[
"<hr>",
"_____no_output_____"
],
[
"Write an if-else statement that performs the following. If the rating is larger then eight print “this album is amazing”. If the rating is less than or equal to 8 print “this album is ok”.",
"_____no_output_____"
]
],
[
[
"# Write your code below and press Shift+Enter to execute",
"this album is ok\n"
]
],
[
[
"Double-click __here__ for the solution.\n\n<!-- \nrating = 8.5\nif rating > 8:\n print (\"this album is amazing\")\nelse:\n print (\"this album is ok\")\n-->",
"_____no_output_____"
],
[
"<hr>",
"_____no_output_____"
],
[
"Write an if statement to determine if an album came out before 1980 or in the years: 1991 or 1993. If the condition is true print out the year the album came out.",
"_____no_output_____"
]
],
[
[
"# Write your code below and press Shift+Enter to execute",
"this album came out already\n"
]
],
[
[
"Double-click __here__ for the solution.\n\n<!-- \nalbum_year = 1979\n\nif album_year < 1980 or album_year == 1991 or album_year == 1993:\n print (\"this album came out already\")\n-->",
"_____no_output_____"
],
[
"<hr>\n<h2>The last exercise!</h2>\n<p>Congratulations, you have completed your first lesson and hands-on lab in Python. However, there is one more thing you need to do. The Data Science community encourages sharing work. The best way to share and showcase your work is to share it on GitHub. By sharing your notebook on GitHub you are not only building your reputation with fellow data scientists, but you can also show it off when applying for a job. Even though this was your first piece of work, it is never too early to start building good habits. So, please read and follow <a href=\"https://cognitiveclass.ai/blog/data-scientists-stand-out-by-sharing-your-notebooks/\" target=\"_blank\">this article</a> to learn how to share your work.\n<hr>",
"_____no_output_____"
],
[
"<h3>About the Authors:</h3> \n<p><a href=\"https://www.linkedin.com/in/joseph-s-50398b136/\" target=\"_blank\">Joseph Santarcangelo</a> is a Data Scientist at IBM, and holds a PhD in Electrical Engineering. His research focused on using Machine Learning, Signal Processing, and Computer Vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD.</p>",
"_____no_output_____"
],
[
"<p>Other contributors: <a href=\"https://www.linkedin.com/in/jiahui-mavis-zhou-a4537814a\">Mavis Zhou</a>, <a href=\"https://github.com/computationalcore\" target=\"_blank\">Vin Busquet</a>, <a href=\"https://github.com/raphtrajano\" target=\"_blank\">Raph Trajano</a></p>",
"_____no_output_____"
],
[
"<hr>",
"_____no_output_____"
],
[
"<p>Copyright © 2018 IBM Developer Skills Network. This notebook and its source code are released under the terms of the <a href=\"https://cognitiveclass.ai/mit-license/\">MIT License</a>.</p>",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
]
] |
ecea89e0b1e23474bd32e126b8a04dc85679979e | 8,766 | ipynb | Jupyter Notebook | project-proposal.ipynb | dillbeck/bike-path | 5deee812f20a81f1c6c2fdcc40def1a7fd496281 | [
"MIT"
] | null | null | null | project-proposal.ipynb | dillbeck/bike-path | 5deee812f20a81f1c6c2fdcc40def1a7fd496281 | [
"MIT"
] | null | null | null | project-proposal.ipynb | dillbeck/bike-path | 5deee812f20a81f1c6c2fdcc40def1a7fd496281 | [
"MIT"
] | null | null | null | 60.455172 | 1,033 | 0.728154 | [
[
[
"# Project Title: Bikeshare Demand Prediction\nDSCI 521: Data Analysis and Interpretation <br> Summer Term - July 28, 2019 <br> Term Project Phase 1: Scoping an analytics project <br> __Team Members: Stephanie Dillbeck, Christopher Spencer, Zexi Yu__ \n\n\n## Team Background\n\n\n__Stephanie Dillbeck:__ I am currently focused on database management and big data with an interest in cybersecurity as well as HCI. I have a solid background in SQL, with some experience in HTML, Javascript and Java. I’m interested in gaining a solid foundation in Python and basic statistical analysis. \n\n__Christopher Spencer:__ With a background in Mechanical Engineering and transitioning into Aerospace Systems Engineering, I have experience in both mathematics and statistics with a primary focus on computational mechanics. While new to Python in particular, there is definite overlap with my past programming experiences.\n\n__Zexi Yu:__ I am presently focused on the area of machine learning with knowledge of common algorithms and skills mostly in image processing using python on platforms of Tensorflow and Keras. And I would like to grow more into the computer vision area and gain more data analysis skills.",
"_____no_output_____"
],
[
"## Project Domain\n\nFor our project, we would like our analyze transportation data in the United States. The transportation sector is immense, where data may be analyze with respect to the mode of transportation, geographic location, emissions, age of driver or rider, infrastructure (e.g. bike lanes, pedestrian sidewalks), ridesharing, safety, and more. Over the past several years and even decades, electric vehicles, ridesharing, and population migration patterns that have impacted the transportation sector provide ample problems or trends waiting to be discovered. For instance, the social conscious to protect the quality of air and reduce national dependency of foreign oil has been cited as a boon to electric vehicle industry. Also, one could consider how population migration patterns have impacted the sale or ownership of vehicles to ridesharing. Lastly, one could also evaluate how are cities, regions or states are adjusting their transportation budgets in response to those changes to using alternate modes of transportation. \n\nAs we explored possible datasets within the broad category of transportation, our group quickly scoped down our focus to the the subdomain of of Bicycle Transportation. With strong personal interest and an abundance of quality datasets, we further narrowed our topic to the Bike Sharing in Washington D.C. Dataset found on Kaggle.com. This dataset provides a count of bikes rented in the Capital Bikeshare system, along with associated date/time, weather/conditions, and holiday data for a two-year period. Our initial exploration will look at the features of the data to determine which features have the most impact on rental demand.",
"_____no_output_____"
],
[
"## Analytic Tools\n\n__Data cleaning:__ excel, python, pandas, numpy\n\n__Data visualization:__ matplotlib, bokeh, seaborn\n\n__Data analysis:__ sklearn\n",
"_____no_output_____"
],
[
"## Analysis and Exploration of Dataset\nIn choosing a dataset we explored numerous datasets of bike usage data throughout the country and even internationally. There were many pre-processed datasets available, including some with overall bike lane usage counts, journey durations, routes, bike-related incidents, as well as biker demographics, but the most rich data sources seemed to originate from the formalized bikeshare systems within major citites or regions. The Capital Bikeshare dataset was particularly attractive because it already included weather and condition data, as well workday/weekend/holiday information.\n\n#### The visual analysis and exploration phase of our chosen dataset is included here: <br> [Phase 1 Exploration and Analysis](phase-1.ipynb).\n",
"_____no_output_____"
],
[
"## Audience\nOur data analysis will potentially have different applications for different stakeholder groups. Public interest groups or nonprofits may have an interest in our data on bike-share usage to focus their efforts and further their specific missions, as well as engage supporters in the community. Local and state municipalities may use our data to help with infrastructure planning, as well as citizen engagement and social responsibility. Existing businesses may use the data to support employee-engagement and work/life balance efforts, as well as from within their social responsibility platform. Finally, entrepreneurs and start-up business may leverage the data to identify new markets or develop new-to-market products or concepts.\n\n\n## Application\nAt present, the goal for our analysis will be to construct a prediction model for the Capital Bikeshare System in Washington, D.C. As the analysis will take into consideration such things as bike usage, membership, weather, air quality, and holidays, the model created will potentially have application beyond the local environment of Washington, D.C. once these factors are adjusted for in a new location. The prediction model could support business decisions, infrastructure planning, maintenance schedules and community involvement, as well as present new opportunities for products or business concepts. As the project will be presented in the form a of a Jupyter Notebook that contains background information, discussion and code for reproducible results, different stakeholder groups can utilize the prediction model in a way that suits their mission and needs, as well as adapt it to other applications. \n",
"_____no_output_____"
],
[
"## Limits and Improvements\nIf we use linear regression to build our prediction model, in order to improve the prediction accuracy, we may want to do some feature crosses. For example, we could combine weather and season and build a new feature. However, the performance may be limited if we just randomly combine them. In this case, we can apply different feature selection models and make comparisons between them. We can keep tuning the model until we achieve an optimal accuracy.\n\n## Continued Analysis\nFrom the result of data visulization above, we can draw some conclusions for continued analysis:\n- The datetime column need to be split into multiple features, including year, month, dayofweek, and hour\n- All columns need to be standardized before creating the feature vectors\n- The atemp column can be dropped due to its high correlation coefficient with temp\n- The demands for casual users and for registered users need to be predicted seperately \n- The outliers need to be removed before creating the feature vectors for hours and workingday\n- The column windspeed can be dropped due to low correlation coefficient with demand\n",
"_____no_output_____"
]
]
] | [
"markdown"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
]
] |
ecea8f4062b077689e6e96a408531ebd83b40984 | 7,322 | ipynb | Jupyter Notebook | pelops/analysis/makeFeaturesResNet50.ipynb | dave-lab41/pelops | 292af80dba190f9506519c8e13432fef648a2291 | [
"Apache-2.0"
] | 48 | 2016-12-11T15:43:28.000Z | 2021-02-28T14:16:42.000Z | pelops/analysis/makeFeaturesResNet50.ipynb | dave-lab41/pelops | 292af80dba190f9506519c8e13432fef648a2291 | [
"Apache-2.0"
] | 100 | 2016-11-15T19:23:52.000Z | 2017-08-22T20:22:13.000Z | pelops/analysis/makeFeaturesResNet50.ipynb | agude/pelops | 292af80dba190f9506519c8e13432fef648a2291 | [
"Apache-2.0"
] | 25 | 2016-11-15T17:49:32.000Z | 2020-02-17T13:04:26.000Z | 26.722628 | 100 | 0.550123 | [
[
[
"cd 'deep-learning-models/'",
"_____no_output_____"
],
[
"import numpy as np\nfrom resnet50 import ResNet50\nfrom keras.preprocessing import image\nfrom imagenet_utils import preprocess_input, decode_predictions\nfrom keras.models import Model\nimport scipy.spatial.distance\nimport time\nimport json\n",
"_____no_output_____"
],
[
"def load_image(img_path):\n data = image.load_img(img_path, target_size=(224, 224))\n x = image.img_to_array(data)\n x = np.expand_dims(x, axis=0)\n x = preprocess_input(x)\n return x",
"_____no_output_____"
],
[
"#def get_base_model():\n# base_model = ResNet50(weights='imagenet',include_top=False)\n# return base_model\n\ndef get_models():\n # include_top needs to be True for this to work\n base_model = ResNet50(weights='imagenet',include_top=True)\n model = Model(input=base_model.input, output=base_model.get_layer('flatten_1').output)\n return (model, base_model)\n\ndef image_features(img,model):\n features = np.zeros((1,2048),dtype=np.float16)\n #model = Model(input=base_model.input, output=base_model.get_layer('flatten_1').output)\n predictions = model.predict(img)\n return predictions",
"_____no_output_____"
],
[
"model, base_model = get_models()",
"_____no_output_____"
],
[
"# model = Model(input=bm.input, output=bm.get_layer('flatten_1').output)",
"_____no_output_____"
],
[
"def save_model_workaround(model, model_output_file, weights_output_file):\n print('saving model to {}'.format(model_output_file))\n print('saving weignts to {}'.format(weights_output_file))\n # serialize model to JSON\n model_json = model.to_json()\n with open(model_output_file, 'w') as json_file:\n json_file.write(model_json)\n # serialize weights to HDF5\n model.save_weights(weights_output_file)\n\n\ndef load_model_workaround(model_output_file, weights_output_file):\n # load json and create model\n json_file = open(model_output_file, 'r')\n loaded_model_json = json_file.read()\n json_file.close()\n loaded_model = model_from_json(loaded_model_json)\n # load weights into new model\n loaded_model.load_weights(weights_output_file)\n return loaded_model",
"_____no_output_____"
],
[
"save_model_workaround(model,\n '/local_data/dgrossman/model_save_dir/dgcars_resenet.model.json',\n '/local_data/dgrossman/model_save_dir/dgcars_resenet.weights.hdf5')",
"_____no_output_____"
],
[
"# print(scipy.spatial.distance.cosine(feature1,feature2),'good')\n# print(scipy.spatial.distance.cosine(feature1,feature3),'bad')\n# print(scipy.spatial.distance.cosine(feature2,feature3),'bad')",
"_____no_output_____"
],
[
"prefix = '/local_data/dgrossman/VeRi/'\n",
"_____no_output_____"
],
[
"tLines = open(prefix + 'trainingLines','r')\ntrainingList = list()\nfor tLine in tLines:\n tLine = tLine.strip()\n tLine = tLine.replace('\"','')\n parts = tLine.split(' ')\n ldict = dict()\n for part in parts:\n l, r = part.split('=')\n ldict[l]=str(r)\n trainingList.append(ldict)\ntLines.close()",
"_____no_output_____"
],
[
"trainingList = list()\ntLines = open(prefix + 'test_features.json','r')\nfor line in tLines:\n line = line.strip()\n line = json.loads(line)\n trainingList.append(line)",
"_____no_output_____"
],
[
"trainingList[0]",
"_____no_output_____"
],
[
"import json\n#outFile = open('/local_data/dgrossman/VeRi/training_features.json','w')\noutFile = open('/local_data/dgrossman/VeRi/test_features.json','w')\n\nbatchSize = 1000\nstart = time.time()\nfor idx,line in enumerate(trainingList):\n tempd = dict()\n if idx % batchSize == 0:\n end = time.time() - start\n start = time.time()\n print ('total {0} batch {1} images in {2} seconds'.format(idx,batchSize,end))\n #img = load_image(prefix + 'image_train/'+line['imageName'])\n img = load_image(prefix + 'image_test/'+line['imageName'])\n feature = image_features(img, model) \n tempd['resnet50'] = feature.tolist()[0]\n tempd.update(line)\n outFile.write(json.dumps(tempd)+'\\n')\noutFile.close()",
"_____no_output_____"
],
[
"funtime = open('/local_data/dgrossman/VeRi/training_features.json','r')\nwork = list()\nfor line in funtime:\n line = line.strip()\n line = json.loads(line)\n work.append(line)\nfuntime.close()",
"_____no_output_____"
],
[
"work[0]\n",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ecea9a1687e92801094c7dc748da10adbf344085 | 2,096 | ipynb | Jupyter Notebook | amz_reports/amz_returns_catalog.ipynb | dyslab/jnb-sample | 38af701866b8496729d63f844e56137d125c4223 | [
"MIT"
] | null | null | null | amz_reports/amz_returns_catalog.ipynb | dyslab/jnb-sample | 38af701866b8496729d63f844e56137d125c4223 | [
"MIT"
] | 2 | 2020-03-24T17:57:15.000Z | 2020-03-31T10:21:49.000Z | amz_reports/amz_returns_catalog.ipynb | dyslab/jnb-sample | 38af701866b8496729d63f844e56137d125c4223 | [
"MIT"
] | null | null | null | 21.833333 | 140 | 0.582538 | [
[
[
"Doc title: **Amazon Returns Report Analyzation Catalog**\n\nArticle notes: The links related to the analyzation of the reports that exported from 'Reports/Fulfillment' @Amazon Seller Central.\n\n文章备注：亚马逊后台退货报告分析链接目录\n\nLast modified date: 2019-09-15 03:20:46 ",
"_____no_output_____"
],
[
"# 亚马逊退货报表目录：",
"_____no_output_____"
],
[
"## 特定时段的FBA退货情况分析，点击：[amz_returns.ipynb](amz_returns.ipynb)",
"_____no_output_____"
],
[
"## FBA退货产品款式占比分析，点击：[amz_returns_model.ipynb](amz_returns_model.ipynb)",
"_____no_output_____"
]
]
] | [
"markdown"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown"
]
] |
eceaa02f44a82e9f569db8f4b57e0c783d8dc5e6 | 15,879 | ipynb | Jupyter Notebook | module1-rnn-and-lstm/LS_DS_431_RNN_and_LSTM_Assignment.ipynb | ToddMG/DS-Unit-4-Sprint-3-Deep-Learning | 93ce8a0254b2def6bf241a42a9e62429f18d42a7 | [
"MIT"
] | null | null | null | module1-rnn-and-lstm/LS_DS_431_RNN_and_LSTM_Assignment.ipynb | ToddMG/DS-Unit-4-Sprint-3-Deep-Learning | 93ce8a0254b2def6bf241a42a9e62429f18d42a7 | [
"MIT"
] | null | null | null | module1-rnn-and-lstm/LS_DS_431_RNN_and_LSTM_Assignment.ipynb | ToddMG/DS-Unit-4-Sprint-3-Deep-Learning | 93ce8a0254b2def6bf241a42a9e62429f18d42a7 | [
"MIT"
] | null | null | null | 33.785106 | 318 | 0.55501 | [
[
[
"<img align=\"left\" src=\"https://lever-client-logos.s3.amazonaws.com/864372b1-534c-480e-acd5-9711f850815c-1524247202159.png\" width=200>\n<br></br>\n<br></br>\n\n## *Data Science Unit 4 Sprint 3 Assignment 1*\n\n# Recurrent Neural Networks and Long Short Term Memory (LSTM)\n\n\n\nIt is said that [infinite monkeys typing for an infinite amount of time](https://en.wikipedia.org/wiki/Infinite_monkey_theorem) will eventually type, among other things, the complete works of Wiliam Shakespeare. Let's see if we can get there a bit faster, with the power of Recurrent Neural Networks and LSTM.\n\nThis text file contains the complete works of Shakespeare: https://www.gutenberg.org/files/100/100-0.txt\n\nUse it as training data for an RNN - you can keep it simple and train character level, and that is suggested as an initial approach.\n\nThen, use that trained RNN to generate Shakespearean-ish text. Your goal - a function that can take, as an argument, the size of text (e.g. number of characters or lines) to generate, and returns generated text of that size.\n\nNote - Shakespeare wrote an awful lot. It's OK, especially initially, to sample/use smaller data and parameters, so you can have a tighter feedback loop when you're trying to get things running. Then, once you've got a proof of concept - start pushing it more!",
"_____no_output_____"
]
],
[
[
"# TODO - Words, words, mere words, no matter from the heart.\n\nfrom tensorflow.keras.preprocessing import sequence\nfrom tensorflow.keras.models import Sequential\nfrom tensorflow.keras.layers import Dense, Embedding\nfrom tensorflow.keras.layers import LSTM\nfrom tensorflow.keras.datasets import imdb\nfrom tensorflow.keras.callbacks import LambdaCallback\nfrom tensorflow.keras.optimizers import RMSprop\n\nimport numpy as np\nimport random\nimport sys\nimport os",
"_____no_output_____"
],
[
"data = []\n\nwith open('100-0.txt', 'r') as f:\n data.append(f.read())",
"_____no_output_____"
],
[
"text = \" \".join(data)\n\nchars = list(set(text))\n\nchar_int = {c:i for i,c in enumerate(chars)}\nint_char = {i:c for i,c in enumerate(chars)}",
"_____no_output_____"
],
[
"len(chars)",
"_____no_output_____"
],
[
"maxlen = 40\nstep = 5\n\nencoded = [char_int[c] for c in text]\n\nsequences = []\nnext_chars = []\n\nfor i in range(0, len(encoded) - maxlen, step):\n sequences.append(encoded[i : i + maxlen])\n next_chars.append(encoded[i + maxlen])\n \nprint('sequences:', len(sequences))",
"sequences: 1114623\n"
],
[
"x = np.zeros((len(sequences), maxlen, len(chars)), dtype=np.bool)\ny = np.zeros((len(sequences), len(chars)), dtype=np.bool)\n\nfor i, sequence in enumerate(sequences):\n for t, char in enumerate(sequence):\n x[i,t,char] = 1\n \n y[i, next_chars[i]] = 1",
"_____no_output_____"
],
[
"x.shape",
"_____no_output_____"
],
[
"y.shape",
"_____no_output_____"
],
[
"model = Sequential()\nmodel.add(LSTM(128, input_shape=(maxlen, len(chars))))\nmodel.add(Dense(len(chars), activation='softmax'))\n\nmodel.compile(loss='categorical_crossentropy', optimizer='adam')",
"_____no_output_____"
],
[
"# Sample temperature function for lecture\ndef sample(preds, temperature=1.0):\n # helper function to sample an index from a probability array\n preds = np.asarray(preds).astype('float64')\n preds = np.log(preds) / temperature\n exp_preds = np.exp(preds)\n preds = exp_preds / np.sum(exp_preds)\n probas = np.random.multinomial(1, preds, 1)\n return np.argmax(probas)",
"_____no_output_____"
],
[
"def on_epoch_end(epoch, _):\n # Function invoked at end of each epoch. Prints generated text.\n \n print()\n print('----- Generating text after Epoch: %d' % epoch)\n \n start_index = random.randint(0, len(text) - maxlen - 1)\n \n generated = ''\n \n sentence = text[start_index: start_index + maxlen]\n generated += sentence\n print('----- Generating with seed: \"' + sentence + '\"')\n sys.stdout.write(generated)\n \n for i in range(400):\n x_pred = np.zeros((1, maxlen, len(chars)))\n for t, char in enumerate(sentence):\n x_pred[0, t, char_int[char]] = 1\n \n preds = model.predict(x_pred, verbose=0)[0]\n next_index = sample(preds, temperature=1.0)\n next_char = int_char[next_index]\n \n sentence = sentence[1:] + next_char\n \n sys.stdout.write(next_char)\n sys.stdout.flush()\n print()\n \nprint_callback = LambdaCallback(on_epoch_end=on_epoch_end)",
"_____no_output_____"
],
[
"model.fit(x, y,\n batch_size=128,\n epochs=5,\n callbacks=[print_callback])",
"Train on 1114623 samples\nEpoch 1/5\n1114496/1114623 [============================>.] - ETA: 0s - loss: 2.2517\n----- Generating text after Epoch: 0\n----- Generating with seed: \"nded are you, and have fought\n Not as\"\nnded are you, and have fought\n Not as sorres harid comsiqurlad is pornew\nLet be quoader in the bridise thesengly wee’t on myip.\n\n [_Exgutt to d’st Soor ANs wath Ciong the Verchiopstt tien,\nHe Is the with ned Gut\n To best’s buck off jold, mars it leve thes\n sfeely at uveet see thyow ane pray ate: I eple wher'd offry roplonduch to wich;\nThou bord,\n Sike awe Feanpy, for didgasse,\n Weat As bave athand then simot; Had speed ulc\n1114623/1114623 [==============================] - 235s 211us/sample - loss: 2.2517\nEpoch 2/5\n1114368/1114623 [============================>.] - ETA: 0s - loss: 1.9045\n----- Generating text after Epoch: 1\n----- Generating with seed: \"efore follow me, and I'll direct you how\"\nefore follow me, and I'll direct you how say!\n KENCENTE. Higat well thit goof come?\n\nREDICETIUS.\nHo! tell will daye for you. Herr-hall knest\nTo clury wares then marchin, araster made my yourr stous at that shand,\n Lere of gringlads woundstion, their wordd,\nBet, and weramile reglmour, know buldeen,\nWMats Eporst baty nation! Alle.\n\nFIMI.\nWith in a to8lat! O there woddsed,\nWhat net and a shand blearena. I pringain,\n Than howrumonier\n1114623/1114623 [==============================] - 228s 205us/sample - loss: 1.9045\nEpoch 3/5\n1114496/1114623 [============================>.] - ETA: 0s - loss: 1.7956\n----- Generating text after Epoch: 2\n----- Generating with seed: \"The way to dusty death. Out, out, brief \"\nThe way to dusty death. Out, out, brief eatharess, me\nHorw? Hulais lovers me, mane here terced;\n Sears a everuchy for you know as all of you hers,\nFood wixh all this woul writ his deesues\n What than Biders unot borts a todder, Or thee’s newn;\nHe withing on this I veiced Loks a gan by notes\nSave the word her wan me to be faik’d this!\n And thou baskss morn’d facking thou but in sir\nIver befunce withable of be they will kneir\nmy H\n1114623/1114623 [==============================] - 230s 206us/sample - loss: 1.7956\nEpoch 4/5\n1114496/1114623 [============================>.] - ETA: 0s - loss: 1.7291\n----- Generating text after Epoch: 3\n----- Generating with seed: \"King;—\nShall it, for shame, be spoken in\"\nKing;—\nShall it, for shame, be spoken in their shing\n Thy frown from marronious.\n\nLASCHAST.\nOul'd. Brest MERe a dought hears to ALIAGH ERVICar Gurst inchand\n\n\n Exeunt\n\n\n\n\n FIRSA.\n Remy that I done shall. Drealizal.\n DOMARD. Their world from to head mis agatsst to it?\n [Twould of followick, 'Tonars. I woom bad who mance\n But coundose I can it that weneswer flous\nToom, By To ghelte\n1114623/1114623 [==============================] - 231s 208us/sample - loss: 1.7291\nEpoch 5/5\n1114496/1114623 [============================>.] - ETA: 0s - loss: 1.6817\n----- Generating text after Epoch: 4\n----- Generating with seed: \"this difference.\nI give consent; are you\"\nthis difference.\nI give consent; are you shall the prome of dead,\n 'Tis visment-mouging shall letter wouldstides\n This frarse acome croend though a chasue that is sonce\n Are more wroth ophanted of your and earthan\n But that thee be homcemped it eyounat\n Thou sweak I cornort for murchous of wark.\n DOCLERANI. Aland.\n ARTZAN. No, a strings, in Majeston's prother liend\n Om. So fissince and shall upword to streaved, I,\nKi\n1114623/1114623 [==============================] - 235s 211us/sample - loss: 1.6817\n"
],
[
"from tensorflow.python.client import device_lib\nprint(device_lib.list_local_devices())",
"[name: \"/device:CPU:0\"\ndevice_type: \"CPU\"\nmemory_limit: 268435456\nlocality {\n}\nincarnation: 789254733241210422\n, name: \"/device:XLA_CPU:0\"\ndevice_type: \"XLA_CPU\"\nmemory_limit: 17179869184\nlocality {\n}\nincarnation: 14510598408632905384\nphysical_device_desc: \"device: XLA_CPU device\"\n, name: \"/device:XLA_GPU:0\"\ndevice_type: \"XLA_GPU\"\nmemory_limit: 17179869184\nlocality {\n}\nincarnation: 11034020051727156322\nphysical_device_desc: \"device: XLA_GPU device\"\n]\n"
]
],
[
[
"# Resources and Stretch Goals",
"_____no_output_____"
],
[
"## Stretch goals:\n- Refine the training and generation of text to be able to ask for different genres/styles of Shakespearean text (e.g. plays versus sonnets)\n- Train a classification model that takes text and returns which work of Shakespeare it is most likely to be from\n- Make it more performant! Many possible routes here - lean on Keras, optimize the code, and/or use more resources (AWS, etc.)\n- Revisit the news example from class, and improve it - use categories or tags to refine the model/generation, or train a news classifier\n- Run on bigger, better data\n\n## Resources:\n- [The Unreasonable Effectiveness of Recurrent Neural Networks](https://karpathy.github.io/2015/05/21/rnn-effectiveness/) - a seminal writeup demonstrating a simple but effective character-level NLP RNN\n- [Simple NumPy implementation of RNN](https://github.com/JY-Yoon/RNN-Implementation-using-NumPy/blob/master/RNN%20Implementation%20using%20NumPy.ipynb) - Python 3 version of the code from \"Unreasonable Effectiveness\"\n- [TensorFlow RNN Tutorial](https://github.com/tensorflow/models/tree/master/tutorials/rnn) - code for training a RNN on the Penn Tree Bank language dataset\n- [4 part tutorial on RNN](http://www.wildml.com/2015/09/recurrent-neural-networks-tutorial-part-1-introduction-to-rnns/) - relates RNN to the vanishing gradient problem, and provides example implementation\n- [RNN training tips and tricks](https://github.com/karpathy/char-rnn#tips-and-tricks) - some rules of thumb for parameterizing and training your RNN",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown"
] | [
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown",
"markdown"
]
] |
eceaacb72619732b97ee1ca42deb5602c96eacbe | 20,718 | ipynb | Jupyter Notebook | pydhamed/tests/test_rna/RNA_test.ipynb | bio-phys/pyDHAMed | d42f2a67a2650a0f8b09a798c2afe3b6d85aab08 | [
"BSD-3-Clause"
] | 21 | 2017-11-14T18:57:23.000Z | 2020-10-17T08:31:07.000Z | pydhamed/tests/test_rna/RNA_test.ipynb | bio-phys/pyDHAMed | d42f2a67a2650a0f8b09a798c2afe3b6d85aab08 | [
"BSD-3-Clause"
] | 11 | 2017-11-07T23:28:21.000Z | 2018-05-24T07:00:55.000Z | pydhamed/tests/test_rna/RNA_test.ipynb | bio-phys/pyDHAMed | d42f2a67a2650a0f8b09a798c2afe3b6d85aab08 | [
"BSD-3-Clause"
] | 4 | 2018-01-04T15:18:49.000Z | 2020-05-08T12:41:52.000Z | 83.540323 | 15,898 | 0.850565 | [
[
[
"# Table of Contents\n <p>",
"_____no_output_____"
]
],
[
[
"pwd",
"_____no_output_____"
],
[
"import numpy as np\n%matplotlib inline\nimport sys\nsys.path.append(\"../\")\nfrom optimize_dhamed import *",
"_____no_output_____"
]
],
[
[
"this should form as the basis of a test. ",
"_____no_output_____"
]
],
[
[
"c_l = [np.genfromtxt(\"count_matrix_1.txt\")]",
"_____no_output_____"
],
[
"v_ar = np.genfromtxt(\"wfile.txt\")[:,1].reshape((9,1))",
"_____no_output_____"
],
[
"og = run_dhamed(c_l, -np.log(v_ar), g_init=-(np.zeros(9))*-1.0, numerical_gradients=False, maxiter=10000)",
"36\nloglike-start 307329.006201\n307329.006201\nOptimization terminated successfully.\n Current function value: 288165.226259\n Iterations: 22\n Function evaluations: 27\n Gradient evaluations: 27\ntime elapsed 0.00710487365723 s\n"
],
[
"ref_f = np.genfromtxt(\"us_dt-e4_2_p1.out\")",
"_____no_output_____"
],
[
"py_rna = og*-1 - (og[-1]*-1)\nf_rna = ref_f[:,-1] - ref_f[-1,-1]",
"_____no_output_____"
],
[
"fig, ax = plt.subplots(figsize=(5,3))\nplt.plot(py_rna, \"o\")\nplt.plot(f_rna)\nax.set_xlabel(\"Reaction coordinate\")\nax.set_ylabel(\"PMF ($\\mathrm{k_BT}$)\")\n\nax.legend()\nfig.tight_layout()",
"_____no_output_____"
],
[
"np.testing.assert_almost_equal(f_rna, py_rna)",
"_____no_output_____"
],
[
"f_rna - py_rna",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
eceac6b66b11b2aebe1bdad9e06c2b6cd8cb2d35 | 21,636 | ipynb | Jupyter Notebook | Wi19_content/DSMCER/L6_MLIntro_filled.ipynb | ShahResearchGroup/UWDIRECT.github.io | d4db958a6bfe151b6f7b1eb4772d8fd1b9bb0c3e | [
"BSD-3-Clause"
] | 1 | 2021-01-26T19:55:02.000Z | 2021-01-26T19:55:02.000Z | Wi19_content/DSMCER/L6_MLIntro_filled.ipynb | ShahResearchGroup/UWDIRECT.github.io | d4db958a6bfe151b6f7b1eb4772d8fd1b9bb0c3e | [
"BSD-3-Clause"
] | null | null | null | Wi19_content/DSMCER/L6_MLIntro_filled.ipynb | ShahResearchGroup/UWDIRECT.github.io | d4db958a6bfe151b6f7b1eb4772d8fd1b9bb0c3e | [
"BSD-3-Clause"
] | null | null | null | 46.730022 | 8,676 | 0.691486 | [
[
[
"import numpy as np\nimport matplotlib.pyplot as plt \nimport pandas as pd \n%matplotlib inline\n# this is a new library you haven't seen before, what do you think it does? \nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.model_selection import train_test_split",
"_____no_output_____"
]
],
[
[
"<img src=\"http://www.nature.com/article-assets/npg/srep/2015/150825/srep13285/images/w926/srep13285-f4.jpg\" width=\"300\" height=\"300\" />\n\nFrom this article in [Scientific Reports](http://www.nature.com/articles/srep13285)",
"_____no_output_____"
],
[
"#### Read in the data\n* elemental data: [https://raw.githubusercontent.com/UWDIRECT/UWDIRECT.github.io/master/Wi18_content/DSMCER/atomsradii.csv](https://raw.githubusercontent.com/UWDIRECT/UWDIRECT.github.io/master/Wi18_content/DSMCER/atomsradii.csv)\n* testing data: [https://raw.githubusercontent.com/UWDIRECT/UWDIRECT.github.io/master/Wi18_content/DSMCER/testing.csv](https://raw.githubusercontent.com/UWDIRECT/UWDIRECT.github.io/master/Wi18_content/DSMCER/testing.csv)",
"_____no_output_____"
]
],
[
[
"d_train = pd.read_csv('https://raw.githubusercontent.com/UWDIRECT/UWDIRECT.github.io/master/Wi18_content/DSMCER/atomsradii.csv')\nd_test = pd.read_csv('https://raw.githubusercontent.com/UWDIRECT/UWDIRECT.github.io/master/Wi18_content/DSMCER/testing.csv')",
"_____no_output_____"
],
[
"d_test",
"_____no_output_____"
]
],
[
[
"Take 1-2 min and look @ the data in elements using pandas and Python you and your partner decide what to do. E.g. you could recreate the above plot with plt.scatter(elements.rWC,elements.rCh)",
"_____no_output_____"
]
],
[
[
"fig, ax = plt.subplots(figsize=(5, 5))\ncolors = ['b', 'r', 'k']\nshapes = ['s', '^', 'o']\n\nfor typ, color, shape in zip(d_train.Type.unique(), colors, shapes):\n ax.scatter(d_train[d_train.Type==typ].rWC, d_train[d_train.Type==typ].rCh, s=200, marker=shape, color=color)\n \nax.set_xlim([0, 1.5])\nax.set_ylim([0, 1.5])",
"_____no_output_____"
]
],
[
[
"#### Now, let's make a new classifier object\n\nWe'll use `KNeighborsClassifier(n_neighbors=k)` where `k` is the number of neighbors to use.\n\n\n\nThen 'train' it using the `.fit` function on the object returned by the `KNeighborsClassifier` call.",
"_____no_output_____"
]
],
[
[
"inputs = ['rWC', 'rCh']\nX_train = d_train[inputs]\ny_train = d_train['Type']\nX_test = d_test[inputs]\ny_test = d_test['Type']\n#X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5)",
"_____no_output_____"
],
[
"KNNmodel = KNeighborsClassifier(n_neighbors=3)",
"_____no_output_____"
],
[
"KNNmodel.fit(X_train, y_train)",
"_____no_output_____"
],
[
"y_train",
"_____no_output_____"
]
],
[
[
"### You can use the following function to see how your model is doing: \n\n`knn.predict(X) `\n\n#### As a function of K, you and your partner should determine: \n* Testing error rate\n* Training error rate \n\n#### Need not be quantitative but spend (1/2 - 2/3 of remaining time exploring this) \n\n",
"_____no_output_____"
]
],
[
[
"rate = KNNmodel.predict(X_train) == y_train\nprint('Training Error Rate:', 1 - np.mean(rate))\n\nrate = KNNmodel.predict(X_test) == y_test\nprint('Testing Error Rate:', 1 - np.mean(rate))",
"Training Error Rate: 0.0\nTesting Error Rate: 0.4\n"
],
[
"rate",
"_____no_output_____"
]
],
[
[
"#### With remaining time go through the cell below and look at graphs of the decision boundary vs K. \n* See if you can use the graph to determine your **testing** error rate \n* Could you also use the graph to determine your **training** error rate? (_open ended_)",
"_____no_output_____"
]
],
[
[
"# additional library we will use \nfrom matplotlib.colors import ListedColormap\n\n# just for convenience and similarity with sklearn tutorial\n# I am going to assign our X and Y data to specific vectors\n# this is not strictly needed and you could use elements df for the whole thing!\nd1 = d_train\nelements = d1\nX=elements[['rWC','rCh']]\n\n#this is a trick to turn our strings (type of element / class) into unique \n#numbers. Play with this in a separate cell and make sure you know wth is \n#going on!\nlevels,labels=pd.factorize(elements.Type)\ny=levels\n\n#This determines levelspacing for our color map and the colors themselves\nh=0.02\ncmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#AAAAFF'])\ncmap_bold = ListedColormap(['#FF0000', '#00FF00', '#0000FF'])\n\n# in the sklearn tutorial two different weights are compared\n# the decision between \"uniform\" and \"distance\" determines the probability\n# weight. \"uniform\" is the version presented in class, you can change to \n# distance\nweights='uniform'\n\n# I am actually refitting the KNN here. If you had a big data set you would\n# not do this, but I want you to have the convenience of changing K or \n# weights here in this cell. Large training sets with many features can take \n# awhile for KNN training! \n\nK=5\nclf = KNeighborsClassifier(n_neighbors=K, weights=weights)\nclf.fit(X,y)\n\n# Straight from the tutorial - quickly read and see if you know what these \n# things are going - if you are < 5 min until end then you should skip this part \n\n# Plot the decision boundary. For that, we will assign a color to each\n# point in the mesh [x_min, x_max]x[y_min, y_max].\nx_min, x_max = elements.rWC.min() - 0.1 , elements.rWC.max() + 0.1\ny_min, y_max = elements.rCh.min() - 0.1 , elements.rCh.max() + 0.1 \nxx, yy = np.meshgrid(np.arange(x_min, x_max, h), \n np.arange(y_min, y_max, h)) \nZ = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n\n# Put the result into a color plot\nZ = Z.reshape(xx.shape)\nplt.figure(figsize=(4,4));\n#plt.pcolormesh(xx, yy, Z, cmap=cmap_light)\nplt.pcolormesh(xx, yy, Z, cmap=cmap_light,vmin=0,vmax=np.max(y))\n# Plot also the training points\n# This may be the 1st time you have seen how to color points by a 3rd vector\n# In this case y ( see c=y in below statement ). This is very useful! \nplt.scatter(X.rWC, X.rCh, c=y, cmap=cmap_bold)\n\n# Set limits and lebels \nplt.xlim(xx.min(), xx.max())\nplt.ylim(yy.min(), yy.max())\nplt.xlabel('rWC')\nplt.ylabel('rCh')",
"_____no_output_____"
]
]
] | [
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
]
] |
eceac83d7e90eb30de2ec088f04b172fc5f6782f | 3,648 | ipynb | Jupyter Notebook | experiments/Atlas/t01_preprocessing.ipynb | gao-lab/GLUE | e84cb6483971dcb1e2485080f812899baaf31b5b | [
"MIT"
] | 41 | 2021-08-23T07:29:55.000Z | 2022-03-12T00:29:52.000Z | experiments/Atlas/t01_preprocessing.ipynb | gao-lab/GLUE | e84cb6483971dcb1e2485080f812899baaf31b5b | [
"MIT"
] | 7 | 2021-11-25T21:25:50.000Z | 2022-02-15T02:22:57.000Z | experiments/Atlas/t01_preprocessing.ipynb | gao-lab/GLUE | e84cb6483971dcb1e2485080f812899baaf31b5b | [
"MIT"
] | 8 | 2021-10-05T07:24:14.000Z | 2022-03-27T22:46:16.000Z | 21.458824 | 92 | 0.536732 | [
[
[
"import os\n\nimport anndata\nimport networkx as nx\nfrom networkx.algorithms.bipartite import biadjacency_matrix",
"_____no_output_____"
],
[
"PATH = \"t01_preprocessing\"\nos.makedirs(PATH, exist_ok=True)",
"_____no_output_____"
]
],
[
[
"# Read data",
"_____no_output_____"
]
],
[
[
"rna = anndata.read_h5ad(\"../../data/dataset/Cao-2020.h5ad\")\natac = anndata.read_h5ad(\"../../data/dataset/Domcke-2020.h5ad\")",
"_____no_output_____"
],
[
"rna_pp = anndata.read_h5ad(\"s01_preprocessing/rna.h5ad\", backed=\"r\")\natac_pp = anndata.read_h5ad(\"s01_preprocessing/atac.h5ad\", backed=\"r\")",
"_____no_output_____"
],
[
"graph = nx.read_graphml(\"s01_preprocessing/full.graphml.gz\")",
"_____no_output_____"
]
],
[
[
"# Update meta",
"_____no_output_____"
]
],
[
[
"rna.var[\"highly_variable\"] = [item in rna_pp.var_names for item in rna.var_names]\natac.var[\"highly_variable\"] = [item in atac_pp.var_names for item in atac.var_names]",
"_____no_output_____"
]
],
[
[
"# Subsample",
"_____no_output_____"
]
],
[
[
"rna = rna[rna_pp.obs[\"mask\"], :]\natac = atac[atac_pp.obs[\"mask\"], :]",
"_____no_output_____"
]
],
[
[
"# Convert data",
"_____no_output_____"
]
],
[
[
"atac2rna = anndata.AnnData(\n X=atac.X @ biadjacency_matrix(graph, atac.var_names, rna.var_names),\n obs=atac.obs, var=rna.var\n)",
"_____no_output_____"
]
],
[
[
"# Save data",
"_____no_output_____"
]
],
[
[
"rna.write(f\"{PATH}/rna.h5ad\", compression=\"gzip\")\natac.write(f\"{PATH}/atac.h5ad\", compression=\"gzip\")\natac2rna.write(f\"{PATH}/atac2rna.h5ad\", compression=\"gzip\")",
"_____no_output_____"
]
]
] | [
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
]
] |
eceacfbebfed2c28d6002e504012df9af7ea3736 | 5,556 | ipynb | Jupyter Notebook | examples/reference/elements/bokeh/RGB.ipynb | pyviz/holoviews | 22db2d1dd3b5d0b42a08f00645e04f693ad63dbb | [
"BSD-3-Clause"
] | 304 | 2019-02-07T16:41:57.000Z | 2019-11-08T23:43:33.000Z | examples/reference/elements/bokeh/RGB.ipynb | pyviz/holoviews | 22db2d1dd3b5d0b42a08f00645e04f693ad63dbb | [
"BSD-3-Clause"
] | 689 | 2019-02-07T00:01:16.000Z | 2019-11-11T22:42:58.000Z | examples/reference/elements/bokeh/RGB.ipynb | pyviz/holoviews | 22db2d1dd3b5d0b42a08f00645e04f693ad63dbb | [
"BSD-3-Clause"
] | 61 | 2019-02-08T17:06:30.000Z | 2019-11-02T21:32:50.000Z | 31.748571 | 505 | 0.573794 | [
[
[
"<div class=\"contentcontainer med left\" style=\"margin-left: -50px;\">\n<dl class=\"dl-horizontal\">\n <dt>Title</dt> <dd> RGB Element</dd>\n <dt>Dependencies</dt> <dd>Bokeh</dd>\n <dt>Backends</dt>\n <dd><a href='./RGB.ipynb'>Bokeh</a></dd>\n <dd><a href='../matplotlib/RGB.ipynb'>Matplotlib</a></dd>\n <dd><a href='../plotly/RGB.ipynb'>Plotly</a></dd>\n</dl>\n</div>",
"_____no_output_____"
]
],
[
[
"import numpy as np\nimport holoviews as hv\nfrom holoviews import opts\nhv.extension('bokeh')",
"_____no_output_____"
]
],
[
[
"``RGB`` represents a regularly spaced 2D grid of an underlying continuous space of RGB(A) (red, green, blue, and alpha) color space values. The definition of the grid closely matches the semantics of an Image and in the simplest case the grid may be specified as a ``NxMx3`` or ``NxMx4`` array of values along with a bounds. An RGB may also be defined through explicit and regularly spaced x/y-coordinate arrays. The two most basic supported constructors of an ``RGB`` element therefore include:\n\n RGB((X, Y, R, G, B))\n\nwhere ``X`` is a 1D array of shape ``M``, ``Y`` is a 1D array of shape ``N`` and ``R``/``G``/``B`` are 2D array of shape ``NxM``, or equivalently:\n\n RGB(Z, bounds=(x0, y0, x1, y1))\n\nwhere Z is a 3D array of stacked R/G/B arrays with shape NxMx3/4 and the bounds define the (left, bottom, right, top) edges of the four corners of the grid. Other gridded formats which support declaring of explicit x/y-coordinate arrays such as xarray are also supported. See the [Gridded Datasets](../../../user_guide/09-Gridded_Datasets.ipynb) user guide for all the other accepted data formats.\n\nOne of the simplest ways of creating an ``RGB`` element is to load an image file (such as PNG) off disk, using the ``load_image`` classmethod:",
"_____no_output_____"
]
],
[
[
"hv.RGB.load_image('../assets/penguins.png')",
"_____no_output_____"
]
],
[
[
"If you have ``PIL`` or [``pillow``](https://python-pillow.org) installed, you can also pass in a PIL Image as long as you convert it to Numpy arrays first:\n\n```\nfrom PIL import Image\nhv.RGB(np.array(Image.open('../assets/penguins.png')))\n```\n\nThis Numpy-based method for constructing an ``RGB`` can be used to stack up arbitrary 2D arrays into a color image:",
"_____no_output_____"
]
],
[
[
"x,y = np.mgrid[-50:51, -50:51] * 0.1\n\nr = 0.5*np.sin(np.pi +3*x**2+y**2)+0.5\ng = 0.5*np.sin(x**2+2*y**2)+0.5\nb = 0.5*np.sin(np.pi/2+x**2+y**2)+0.5\n\nhv.RGB(np.dstack([r,g,b]))",
"_____no_output_____"
]
],
[
[
"You can see how the RGB object is created from the original channels as gray `Image` elements:",
"_____no_output_____"
]
],
[
[
"opts.defaults(opts.Image(cmap='gray'))",
"_____no_output_____"
]
],
[
[
"Now we can index the components:",
"_____no_output_____"
]
],
[
[
"hv.Image(r,label=\"R\") + hv.Image(g,label=\"G\") + hv.Image(b,label=\"B\")",
"_____no_output_____"
]
],
[
[
"``RGB`` also supports an optional alpha channel, which will be used as a mask revealing or hiding any ``Element``s it is overlaid on top of:",
"_____no_output_____"
]
],
[
[
"mask = 0.5*np.sin(0.2*(x**2+y**2))+0.5\nrgba = hv.RGB(np.dstack([r,g,b,mask]))\n\nbg = hv.Image(0.5*np.cos(x*3)+0.5, label=\"Background\") * hv.VLine(x=0,label=\"Background\")\noverlay = (bg*rgba).relabel(\"RGBA Overlay\")\nbg + hv.Image(mask,label=\"Mask\") + overlay",
"_____no_output_____"
]
],
[
[
"RGB elements can be positioned in the plot space using their bounds, with transparency if defined for that image:",
"_____no_output_____"
]
],
[
[
"hv.Overlay([hv.RGB.load_image('../assets/penguins.png', bounds=(2*i,2*i,3*i,3*i))\n for i in range(1,8)])",
"_____no_output_____"
]
],
[
[
"One additional way to create RGB objects is via the separate [ImaGen](https://github.com/pyviz-topics/imagen) library, which creates parameterized streams of images for experiments, simulations, or machine-learning applications.\n\nFor full documentation and the available style and plot options, use ``hv.help(hv.RGB).``",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
]
] |
eceae72484c16ac4f2dec907091b74f48b29fe34 | 12,657 | ipynb | Jupyter Notebook | posts/wip/partitions_1.ipynb | willboulton/blog | 304946d1e9c7edcf7a9af684e7fb27b6fb546153 | [
"MIT"
] | null | null | null | posts/wip/partitions_1.ipynb | willboulton/blog | 304946d1e9c7edcf7a9af684e7fb27b6fb546153 | [
"MIT"
] | null | null | null | posts/wip/partitions_1.ipynb | willboulton/blog | 304946d1e9c7edcf7a9af684e7fb27b6fb546153 | [
"MIT"
] | null | null | null | 74.452941 | 677 | 0.6624 | [
[
[
"# Partition Numbers 1\n\nThis is based on a lecture I gave for some 6th formers in 2017.\n\n\nMathematicians are often stereotyped as people who like to count things; generally speaking this is an incorrect judgement and mathematics as a subject goes far further than 'accounting-like' tasks. However, in this talk I am going to talk about a very classical subject, dating back to Euler and even before - and this subject area called arithmetic number theory is in fact to do with ways of counting things. \n\n#### Ways of counting stuff\n\n\nHere's a pretty simple question; if I've got 5 identical beads, how many ways can I split them up into different piles? Well, here are some different combinations:\n\n- 5\n- 1 + 1 + 1 + 1 + 1\n- 2 + 3\n- 4 + 1\n- some other ways?\n\nAfter listing a few, we should probably try to approach this problem at least a little bit methodically, so I'm going to start with 1 pile (5) and work my way up to 5 piles (1+1+1+1+1):\n\n- 5\n- 4 + 1\n- 3 + 2\n- 3 + 1 + 1\n- 2 + 2 + 1\n- 2 + 1 + 1 + 1\n- 1 + 1 + 1 + 1 + 1\n\nWe've done this systematically, counting down from the largest number, and always using the largest values where possible, so we've definitely not left any possibilities out. So that's the answer; there are 7 ways to split 5 beads into various piles. If you wanted to write this using mathematical notation, you could summarise this by writing that p(5) = 7, where we are defining p as a function which takes a natural number n as input and returns the number of ways of writing n.\n\nBy the way, these 'possible ways' are called partitions, and the number of ways (as described by this function p) is called the partition function. \n\nYou might reasonably ask \"What is the point of this?\". That's a completely fair question. In many branches of mathematics, and science more generally, it's common to start off with some daft question, and generalise it, or ask some follow up question, until things become both more difficult, but also more interesting and applicable to the real world. In this case, there are a lot of different follow-up questions:\n\n1. This counting process worked for 5, but what about 10, or 200, or a million? Is there a general pattern / a formula? If you graph these, what's the general shape of the graph?\n2. Is there a way of speeding up this counting process? Or say someone wants to know the same problem but with 6 instead of 5, do I have to do all of the work again, or does knowing the answer with 5 help?\n3. What if the order doesn't matter? So that you're allowed 4 + 1 and 1 + 4 as being different and 2 + 2 + 1 is different to 2 + 1 + 2 which is different to 1 + 2 + 2. Is there a formula then?\n4. What if you're only allowed to use different numbers (no repeats)? What if you're only allowed to use odd numbers? Or only allowed to use even numbers? Or square numbers? Or some other restriction?\n\nTo use more technical terminology, we want to generalise this question in different ways: using any number (call it n) instead of 5 (Q1), having more (or less) restrictive rules on how to divide up n (Q3 and Q4), and asking for a closed formula (Q1), asymptotic equation (Q1), and an efficient algorithm to compute these numbers, or a recursive algorithm; we'd also like to know the runtime of the algorithm (Q2). \n\nBefore reading on, you should try to investigate some of these questions for yourself. You could try computing some of these numbers by hand and drawing out a table, or writing a computer program to do it for you, and graphing the results. In particular, you could try Q3, and draw out a table for Q4 using either only even numbers, only odd numbers, or only distinct numbers. \n\n\n#### Partitions\n\n\nIf you're still reading this I'm assuming you either got bored of trying the question yourself, or you did it. Either way, here's how I approached the problem of counting the partitions of a natural number, where you are allowed repeated entries in the sum, and the order of the summands matters (i.e. question 3 above). \n\nTo get started, just work out the first few possibilities. I'll write n for the number we're testing, and r(n) for the number of ways of making n when you're allowed repeats:",
"_____no_output_____"
],
[
"| n | r(n) | Options |\n|-----|------|---------|\n| 1 | 1 | 1 |\n| 2 | 2 | 2, 1 + 1|\n| 3 | 4 | 3, 2 + 1, 1 + 2, 1 + 1 + 1|\n| 4 | 8 | 4, 3 + 1, 2 + 2, 2 + 1 + 1, 1 + 3 ...etc.|",
"_____no_output_____"
],
[
"It looks like the pattern here is powers of two - $ r(n) = 2 ^ {n-1} $. Great! Are we finished? Unfortunately, just working out the first 4 terms in a sequence and spotting a pattern doesn't really constitute a proof. That kind of logic can be pretty persuasive to set up a hypothesis, but for a mathematician, there's still plenty of work left to do. To be sure, we need to come up with a foolproof argument for why our guess for this formula of r(n) is right. \n\n\n#### Back to Partitions\nLet's define a set of functions:\n Given an input n (the symbol means \"is an element of\" and the N is the set of natural numbers, so 1, 2, 3, 4, ...etc.) let's define-\n \n - p(n) is the number of partitions of n\n - r(n) is the number of partitions of n where re-orderings are allowed\n - e(n) is the number of partitions of n using only even numbers\n - o(n) is the number of partitions of n using only odd numbers\n - d(n) is the number of partitions of n using only distinct numbers (no repeats allowed)\n\nWe've already worked out an exact formula for r(n) - it's 2 ** (n-1). So that's an open and shut case. Are there any other easy things we can think of? Well, e(n) is pretty obviously going to be 0 whenever n is odd (you can't make an odd number by adding together a bunch of even numbers), and when n is even, e(n) is just the same thing as p(n/2) (divide all your piles in half). So we have a complete formula for e(n) too: \n\ne(n) = { 0 if n is odd; p(n/2) if n is even;\n\nThis is another general mathematical principle - reducing one problem to another. I don't have a formula for e(n) but I do know that it's almost the same as p(n/2); so actually the e(n) problem is no harder or easier than working things out for p(n). \n\nWhat about these other ones though? I've drawn out a table below. \n\nHow weird. It looks like there are just as many ways of splitting a number up into odd parts as there are for splitting it up into distinct (ie. different) parts. That's pretty crazy. In fact it's so crazy that it's probably worth investigating a bit more. I've written a computer program which does this, and prints the results. The code is in the appendix, but the results are given here below. If you're keen, and know some coding, I'd suggest you write your own code to check this too. \n\n#### Summary\n\n#### Appendix - Some coding\nBeing able to code is a pretty useful skill for almost every technical or scientific field. If you know a little bit of coding, I would strongly encourage you to try to write programs that can calculate partition numbers. I've put some code in a github repository which you are free to mess with as much as you like. However, if you don't know any coding, you can still get started a bit. Just make sure you do the following steps:\n\n1. Open a new tab in your browser.\n2. Go on the three dots next to the url bar, click it and look for \"Developer Tools\". In Chrome, it's under \"More Tools\" > \"Developer Tools\" and the shortcut is Control + Shift + I. \n3. Click the Console tab. This opens an interactive console where you can type in any valid javascript code and the console will evaluate it for you. \n4. Try typing in some maths operations like 2 + 2, or 6 ** 3 (to run that line of code you need to hit enter). \n5. Type in the command: \n\n{% highlight javascript %}\nfetch().then(response => response.text).then()\n{% endhighlight %}\n\nThis copies the code from http://sekjsjf directly into the console. You can now use that code even if you don't understand exactly what it does! (This is 99% of programming.)\n6. Still in the console, type in Partitions.partition(5) and hit enter. The console should return 7 as the answer. But there are a whole load of other functions that you can try using. There's a handy autocomplete function, and a drop down, showing you a range of available options. Try typing in Partitions.partition.text(), Partitions.odd.text(), Partitions.distinct.text() to get a short description of what each function does. \n7. Try using some other commands. Writing Partitions.odd(5, list=True) will return [1,2,3,4,5]; i.e. rather than just calculating the answer for 5 it will run through all the numbers up to 5 and return the answers for each in an array. \n8. What about if we want to check that d(n) = o(n) for every single number up to 100? We could try writing some code like this:\n\n{% highlight javascript %}\nfor (let i = 1; i < 100; i = i + 1) {\n if (Partitions.odd(i) === Partitions.distinct(i)) {\n console.log(\"Same\")\n }\n else {\n console.log(\"These two are different!\")\n }\n}\n{% endhighlight %}\n\nThere are loads of good javascript tutorials (here's just one) but as a super crash course:\n\n- A single equals sign assigns a variable a value. i = 1 assigns the variable i a value of 1. \n- triple equals checks for equality. So something like (2 + 2 === 4) evaluates as true. \n- for (let i = 1; i < 100; i++) {do some stuff} looks more intimidating, but it's still pretty simple. We start by creating a new variable called i and giving it the value 1 (let i = 1;). Next we do whatever is in the curly brackets. Once that's done, we add 1 to the value of i (that's the i = i + 1, which looks weird, but remember that a single equals sign in javascript is an assignment, so really this is saying \"I want you to assign the variable i a new value, by taking its current value and adding 1 to it\"). Then we evaluate what's in the curly brackets, using the updated value for i. We keep doing this until i reaches 100 ( i < 100;), when we can stop. \n- if (something) {do this} else {do that} is pretty self explanatory. If the condition inside the if (something) is evaluated as true, we do what's inside the first set of brackets. Otherwise, we do whatever the else part says. \n- console.log(\"whatever\") just tells the console to print out that line. \n\nSo in the code here, we assign a new variable called i the value 1. Then we check if Partitions.odd(i) and Partitions.distinct(i) are equal, and if they are we print \"Same\", otherwise we print \"These two are different!\". Then we add 1 to the value of i (that's the i = i + 1 part) and do it again. We keep on doing this until i hits 100, when we can stop. One thing to note is that in javascript (and in programming in general) adding 1 to a variable is so common that it has a shorthand - rather than writing i = i + 1, you can write i++, which is more compact but means the same thing. ",
"_____no_output_____"
]
]
] | [
"markdown"
] | [
[
"markdown",
"markdown",
"markdown"
]
] |
eceaf3e199f8d6e090e416572afab9b5f5d82d59 | 899,481 | ipynb | Jupyter Notebook | legacy/unidad_2/03_debug.ipynb | LVFerrero/diseno_sci_sfw | d782c0b6ccd5dbfd7c59fd2ac408207470e22301 | [
"BSD-3-Clause"
] | 1 | 2020-10-15T12:48:48.000Z | 2020-10-15T12:48:48.000Z | legacy/unidad_2/03_debug.ipynb | LVFerrero/diseno_sci_sfw | d782c0b6ccd5dbfd7c59fd2ac408207470e22301 | [
"BSD-3-Clause"
] | null | null | null | legacy/unidad_2/03_debug.ipynb | LVFerrero/diseno_sci_sfw | d782c0b6ccd5dbfd7c59fd2ac408207470e22301 | [
"BSD-3-Clause"
] | null | null | null | 5,518.288344 | 893,228 | 0.963797 | [
[
[
"\n# Diseño de software para cómputo científico\n\n----\n\n## Unidad 2: Depuración de código\n",
"_____no_output_____"
],
[
"### Agenda de la Unidad 2\n---\n\n**Clase 1**\n \n - Calidad de software.\n - Principios de diseño: DRY y KISS \n - Refactoreo.\n\n**Clase 2**\n \n - Depuración de código.\n - Pruebas unitarias y funcionales con pytest.\n - Testing basados en propiedades (Hypothesis).\n\n**Clase 3**\n\n - Cobertura de código (codecov).\n - Perfilado de código\n",
"_____no_output_____"
],
[
"## Depuración\n\nLa depuración de programas es el proceso de identificar y corregir errores de programación. En inglés se conoce como debugging, porque se asemeja a la eliminación de bichos (bugs), manera en que se conoce informalmente a los errores de programación.\n\n",
"_____no_output_____"
],
[
"## Dos depuradores principales en Python\n\n- Lo que vamos a ver es **Interactive debugging**\n- ``pdb`` (Python debugger) viene con python y es bastante tosco.\n- ``ipdb`` (IPython debugger) hay que instalarlo y es ultra cómodo.\n- En pytest siempre ejecutar con `-s`.",
"_____no_output_____"
]
],
[
[
"!pip install ipdb",
"Requirement already satisfied: ipdb in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (0.12.2)\nRequirement already satisfied: ipython>=5.1.0; python_version >= \"3.4\" in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from ipdb) (7.5.0)\nRequirement already satisfied: setuptools in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from ipdb) (41.0.1)\nRequirement already satisfied: pexpect; sys_platform != \"win32\" in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (4.7.0)\nRequirement already satisfied: pickleshare in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (0.7.5)\nRequirement already satisfied: prompt-toolkit<2.1.0,>=2.0.0 in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (2.0.9)\nRequirement already satisfied: pygments in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (2.4.2)\nRequirement already satisfied: traitlets>=4.2 in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (4.3.2)\nRequirement already satisfied: decorator in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (4.4.0)\nRequirement already satisfied: jedi>=0.10 in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (0.13.3)\nRequirement already satisfied: backcall in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (0.1.0)\nRequirement already satisfied: ptyprocess>=0.5 in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from pexpect; sys_platform != \"win32\"->ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (0.6.0)\nRequirement already satisfied: six>=1.9.0 in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from prompt-toolkit<2.1.0,>=2.0.0->ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (1.12.0)\nRequirement already satisfied: wcwidth in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from prompt-toolkit<2.1.0,>=2.0.0->ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (0.1.7)\nRequirement already satisfied: ipython-genutils in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from traitlets>=4.2->ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (0.2.0)\nRequirement already satisfied: parso>=0.3.0 in /home/juan/proyectos/diseno_sci_sfw/lib/python3.7/site-packages (from jedi>=0.10->ipython>=5.1.0; python_version >= \"3.4\"->ipdb) (0.4.0)\n\u001b[33mWARNING: You are using pip version 19.1.1, however version 19.2.3 is available.\nYou should consider upgrading via the 'pip install --upgrade pip' command.\u001b[0m\n"
]
],
[
[
"## IPDB \nPara poner un break point hay que poner `import ipdb; ipdb.set_trace()`\n\nO si quieren que se active en las exceptions usar\n\n```python\nfrom ipdb import launch_ipdb_on_exception\n\nwith launch_ipdb_on_exception():\n ...\n```",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
]
] |
eceb022e312c94df1abcfb4dc44570ee047f0ff6 | 28,440 | ipynb | Jupyter Notebook | pml1/figure_notebooks/chapter1_introduction_figures.ipynb | hanchenresearch/pml-book | 2c1b327b983bb7d9c57dd99491e24bd77b870d5a | [
"MIT"
] | 1 | 2021-08-30T23:47:45.000Z | 2021-08-30T23:47:45.000Z | pml1/figure_notebooks/chapter1_introduction_figures.ipynb | luaburto/pml-book | d28d516434f5fef847d1402ee3c39660c60815e1 | [
"MIT"
] | null | null | null | pml1/figure_notebooks/chapter1_introduction_figures.ipynb | luaburto/pml-book | d28d516434f5fef847d1402ee3c39660c60815e1 | [
"MIT"
] | 1 | 2021-11-05T20:05:38.000Z | 2021-11-05T20:05:38.000Z | 31.529933 | 860 | 0.585267 | [
[
[
"# Copyright 2021 Google LLC\n# Use of this source code is governed by an MIT-style\n# license that can be found in the LICENSE file or at\n# https://opensource.org/licenses/MIT.\n# Notebook authors: Kevin P. Murphy ([email protected])\n# and Mahmoud Soliman ([email protected])\n\n# This notebook reproduces figures for chapter 1 from the book\n# \"Probabilistic Machine Learning: An Introduction\"\n# by Kevin Murphy (MIT Press, 2021).\n# Book pdf is available from http://probml.ai",
"_____no_output_____"
]
],
[
[
"<a href=\"https://opensource.org/licenses/MIT\" target=\"_parent\"><img src=\"https://img.shields.io/github/license/probml/pyprobml\"/></a>",
"_____no_output_____"
],
[
"<a href=\"https://colab.research.google.com/github/probml/pml-book/blob/main/pml1/figure_notebooks/chapter1_introduction_figures.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>",
"_____no_output_____"
],
[
"## Figure 1.1:<a name='1.1'></a> <a name='iris'></a> ",
"_____no_output_____"
],
[
"\n Three types of Iris flowers: Setosa, Versicolor and Virginica. Used with kind permission of Dennis Kramb and SIGNA",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
]
],
[
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.1_A.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.1_B.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.1_C.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"## Figure 1.2:<a name='1.2'></a> <a name='cat'></a> ",
"_____no_output_____"
],
[
"\n Illustration of the image classification problem. From https://cs231n.github.io/ . Used with kind permission of Andrej Karpathy",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
]
],
[
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.2.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"## Figure 1.3:<a name='1.3'></a> <a name='irisPairs'></a> ",
"_____no_output_____"
],
[
"\n Visualization of the Iris data as a pairwise scatter plot. On the diagonal we plot the marginal distribution of each feature for each class. The off-diagonals contain scatterplots of all possible pairs of features. \nFigure(s) generated by [iris_plot.py](https://github.com/probml/pyprobml/blob/master/scripts/iris_plot.py) ",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
],
[
"deimport(superimport)\n%run iris_plot.py",
"_____no_output_____"
]
],
[
[
"## Figure 1.4:<a name='1.4'></a> <a name='dtreeIrisDepth2'></a> ",
"_____no_output_____"
],
[
"\n Example of a decision tree of depth 2 applied to the Iris data, using just the petal length and petal width features. Leaf nodes are color coded according to the predicted class. The number of training samples that pass from the root to a node is shown inside each box; we show how many values of each class fall into this node. This vector of counts can be normalized to get a distribution over class labels for each node. We can then pick the majority class. Adapted from Figures 6.1 and 6.2 of <a href='#Geron2019'>[Aur19]</a> . ",
"_____no_output_____"
],
[
"To reproduce this figure, click the open in colab button: <a href=\"https://colab.research.google.com/github/probml/probml-notebooks/blob/master/notebooks/iris_dtree.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
]
],
[
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.4_A.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.4_B.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"## Figure 1.5:<a name='1.5'></a> <a name='linreg'></a> ",
"_____no_output_____"
],
[
"\n(a) Linear regression on some 1d data. (b) The vertical lines denote the residuals between the observed output value for each input (blue circle) and its predicted value (red cross). The goal of least squares regression is to pick a line that minimizes the sum of squared residuals. \nFigure(s) generated by [linreg_residuals_plot.py](https://github.com/probml/pyprobml/blob/master/scripts/linreg_residuals_plot.py) ",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
],
[
"deimport(superimport)\n%run linreg_residuals_plot.py",
"_____no_output_____"
]
],
[
[
"## Figure 1.6:<a name='1.6'></a> <a name='polyfit2d'></a> ",
"_____no_output_____"
],
[
"\n Linear and polynomial regression applied to 2d data. Vertical axis is temperature, horizontal axes are location within a room. Data was collected by some remote sensing motes at Intel's lab in Berkeley, CA (data courtesy of Romain Thibaux). (a) The fitted plane has the form $ f ( \\bm x ) = w_0 + w_1 x_1 + w_2 x_2$. (b) Temperature data is fitted with a quadratic of the form $ f ( \\bm x ) = w_0 + w_1 x_1 + w_2 x_2 + w_3 x_1^2 + w_4 x_2^2$. \nFigure(s) generated by [linreg_2d_surface_demo.py](https://github.com/probml/pyprobml/blob/master/scripts/linreg_2d_surface_demo.py) ",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
],
[
"deimport(superimport)\n%run linreg_2d_surface_demo.py",
"_____no_output_____"
]
],
[
[
"## Figure 1.7:<a name='1.7'></a> <a name='linregPoly'></a> ",
"_____no_output_____"
],
[
"\n(a-c) Polynomials of degrees 2, 14 and 20 fit to 21 datapoints (the same data as in \\cref fig:linreg ). (d) MSE vs degree. \nFigure(s) generated by [linreg_poly_vs_degree.py](https://github.com/probml/pyprobml/blob/master/scripts/linreg_poly_vs_degree.py) ",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
],
[
"deimport(superimport)\n%run linreg_poly_vs_degree.py",
"_____no_output_____"
]
],
[
[
"## Figure 1.8:<a name='1.8'></a> <a name='eqn:irisClustering'></a> ",
"_____no_output_____"
],
[
"\n(a) A scatterplot of the petal features from the iris dataset. (b) The result of unsupervised clustering using $K=3$. \nFigure(s) generated by [iris_kmeans.py](https://github.com/probml/pyprobml/blob/master/scripts/iris_kmeans.py) ",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
],
[
"deimport(superimport)\n%run iris_kmeans.py",
"_____no_output_____"
]
],
[
[
"## Figure 1.9:<a name='1.9'></a> <a name='pcaDemo'></a> ",
"_____no_output_____"
],
[
"\n(a) Scatterplot of iris data (first 3 features). Points are color coded by class. (b) We fit a 2d linear subspace to the 3d data using PCA. The class labels are ignored. Red dots are the original data, black dots are points generated from the model using $ \\bm x = \\mathbf W \\bm z + \\bm \\mu $, where $ \\bm z $ are latent points on the underlying inferred 2d linear manifold. \nFigure(s) generated by [iris_pca.py](https://github.com/probml/pyprobml/blob/master/scripts/iris_pca.py) ",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
],
[
"deimport(superimport)\n%run iris_pca.py",
"_____no_output_____"
]
],
[
[
"## Figure 1.10:<a name='1.10'></a> <a name='humanoid'></a> ",
"_____no_output_____"
],
[
"\n Examples of some control problems. (a) Space Invaders Atari game. From https://gym.openai.com/envs/SpaceInvaders-v0/ . (b) Controlling a humanoid robot in the MuJuCo simulator so it walks as fast as possible without falling over. From https://gym.openai.com/envs/Humanoid-v2/ ",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
]
],
[
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.10_A.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.10_B.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"## Figure 1.11:<a name='1.11'></a> <a name='cake'></a> ",
"_____no_output_____"
],
[
"\n The three types of machine learning visualized as layers of a chocolate cake. This figure (originally from https://bit.ly/2m65Vs1 ) was used in a talk by Yann LeCun at NIPS'16, and is used with his kind permission",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
]
],
[
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.11.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"## Figure 1.12:<a name='1.12'></a> <a name='emnist'></a> ",
"_____no_output_____"
],
[
"\n(a) Visualization of the MNIST dataset. Each image is $28 \\times 28$. There are 60k training examples and 10k test examples. We show the first 25 images from the training set. \nFigure(s) generated by [mnist_viz_tf.py](https://github.com/probml/pyprobml/blob/master/scripts/mnist_viz_tf.py) [emnist_viz_pytorch.py](https://github.com/probml/pyprobml/blob/master/scripts/emnist_viz_pytorch.py) ",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
],
[
"deimport(superimport)\n%run mnist_viz_tf.py",
"_____no_output_____"
],
[
"deimport(superimport)\n%run emnist_viz_pytorch.py",
"_____no_output_____"
]
],
[
[
"## Figure 1.13:<a name='1.13'></a> <a name='CIFAR'></a> ",
"_____no_output_____"
],
[
"\n(a) Visualization of the Fashion-MNIST dataset <a href='#fashion'>[XRV17]</a> . The dataset has the same size as MNIST, but is harder to classify. There are 10 classes: T-shirt/top, Trouser, Pullover, Dress, Coat, Sandal, Shirt, Sneaker, Bag, Ankle-boot. We show the first 25 images from the training set. \nFigure(s) generated by [fashion_viz_tf.py](https://github.com/probml/pyprobml/blob/master/scripts/fashion_viz_tf.py) [cifar_viz_tf.py](https://github.com/probml/pyprobml/blob/master/scripts/cifar_viz_tf.py) ",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
],
[
"deimport(superimport)\n%run fashion_viz_tf.py",
"_____no_output_____"
],
[
"deimport(superimport)\n%run cifar_viz_tf.py",
"_____no_output_____"
]
],
[
[
"## Figure 1.14:<a name='1.14'></a> <a name='imagenetError'></a> ",
"_____no_output_____"
],
[
"\n(a) Sample images from the \\bf ImageNet dataset <a href='#ILSVRC15'>[Rus+15]</a> . This subset consists of 1.3M color training images, each of which is $256 \\times 256$ pixels in size. There are 1000 possible labels, one per image, and the task is to minimize the top-5 error rate, i.e., to ensure the correct label is within the 5 most probable predictions. Below each image we show the true label, and a distribution over the top 5 predicted labels. If the true label is in the top 5, its probability bar is colored red. Predictions are generated by a convolutional neural network (CNN) called ``AlexNet'' (\\cref sec:alexNet ). From Figure 4 of <a href='#Krizhevsky12'>[KSH12]</a> . Used with kind permission of Alex Krizhevsky. (b) Misclassification rate (top 5) on the ImageNet competition over time. Used with kind permission of Andrej Karpathy",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
]
],
[
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.14_A.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.14_B.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"## Figure 1.15:<a name='1.15'></a> <a name='termDoc'></a> ",
"_____no_output_____"
],
[
"\n Example of a term-document matrix, where raw counts have been replaced by their TF-IDF values (see \\cref sec:tfidf ). Darker cells are larger values. From https://bit.ly/2kByLQI . Used with kind permission of Christoph Carl Kling",
"_____no_output_____"
]
],
[
[
"#@title Click me to run setup { display-mode: \"form\" }\ntry:\n if PYPROBML_SETUP_ALREADY_RUN:\n print('skipping setup')\nexcept:\n PYPROBML_SETUP_ALREADY_RUN = True\n print('running setup...')\n !git clone --depth 1 https://github.com/probml/pyprobml /pyprobml &> /dev/null \n %cd -q /pyprobml/scripts\n %reload_ext autoreload \n %autoreload 2\n !pip install superimport deimport -qqq\n import superimport\n from deimport.deimport import deimport\n print('finished!')",
"_____no_output_____"
]
],
[
[
"<img src=\"https://raw.githubusercontent.com/probml/pml-book/main/pml1/figures/images/Figure_1.15.png\" width=\"256\"/>",
"_____no_output_____"
],
[
"## References:\n <a name='Geron2019'>[Aur19]</a> G. Aur'elien \"Hands-On Machine Learning with Scikit-Learn and TensorFlow: Concepts, Tools, and Techniques for BuildingIntelligent Systems (2nd edition)\". (2019). \n\n<a name='Krizhevsky12'>[KSH12]</a> A. Krizhevsky, I. Sutskever and G. Hinton. \"Imagenet classification with deep convolutional neural networks\". (2012). \n\n<a name='ILSVRC15'>[Rus+15]</a> O. Russakovsky, J. Deng, H. Su, J. Krause, S. Satheesh, S. Ma, Z. Huang, A. Karpathy, A. Khosla, M. Bernstein, A. Berg and L. Fei-Fei. \"ImageNet Large Scale Visual Recognition Challenge\". In: ijcv (2015). \n\n<a name='fashion'>[XRV17]</a> H. Xiao, K. Rasul and R. Vollgraf. \"Fashion-MNIST: a Novel Image Dataset for Benchmarking Machine Learning Algorithms\". abs/1708.07747 (2017). arXiv: 1708.07747 \n\n",
"_____no_output_____"
]
]
] | [
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
]
] |
eceb0fc2aebb27f7e9669f84aa89cad2910eccc1 | 782,457 | ipynb | Jupyter Notebook | notebooks/.ipynb_checkpoints/Math156_classification_MNIST-checkpoint_BACKUP_721.ipynb | tylerwu2222/Math156_UCLA_SP21 | 9eb64b1d1bb47837d7a67a0dc5c3f4ed25d6dfd1 | [
"MIT"
] | null | null | null | notebooks/.ipynb_checkpoints/Math156_classification_MNIST-checkpoint_BACKUP_721.ipynb | tylerwu2222/Math156_UCLA_SP21 | 9eb64b1d1bb47837d7a67a0dc5c3f4ed25d6dfd1 | [
"MIT"
] | null | null | null | notebooks/.ipynb_checkpoints/Math156_classification_MNIST-checkpoint_BACKUP_721.ipynb | tylerwu2222/Math156_UCLA_SP21 | 9eb64b1d1bb47837d7a67a0dc5c3f4ed25d6dfd1 | [
"MIT"
] | null | null | null | 420.449758 | 157,976 | 0.92818 | [
[
[
"empty"
]
]
] | [
"empty"
] | [
[
"empty"
]
] |
eceb23e18fd06fa7851c2e85ed96621760319ee1 | 73,952 | ipynb | Jupyter Notebook | titanic/Titanic-Derived.ipynb | Ravirajadrangi/projects6 | bc7dc98a01dabe4b64d7de7738521746b09426cd | [
"BSD-2-Clause"
] | 24 | 2015-12-16T14:44:05.000Z | 2021-04-03T12:11:47.000Z | titanic/Titanic-Derived.ipynb | Ravirajadrangi/projects6 | bc7dc98a01dabe4b64d7de7738521746b09426cd | [
"BSD-2-Clause"
] | null | null | null | titanic/Titanic-Derived.ipynb | Ravirajadrangi/projects6 | bc7dc98a01dabe4b64d7de7738521746b09426cd | [
"BSD-2-Clause"
] | 8 | 2017-03-31T17:36:03.000Z | 2020-01-11T15:59:13.000Z | 41.546067 | 13,299 | 0.42936 | [
[
[
"empty"
]
]
] | [
"empty"
] | [
[
"empty"
]
] |
eceb2a85706c1694a13b414e4b8eac9150ed522c | 24,173 | ipynb | Jupyter Notebook | Survey1Theory_results.ipynb | christopherkullenberg/KT2102Evaluations | dbd7789de37268e8240091609a1115019940879c | [
"MIT"
] | null | null | null | Survey1Theory_results.ipynb | christopherkullenberg/KT2102Evaluations | dbd7789de37268e8240091609a1115019940879c | [
"MIT"
] | null | null | null | Survey1Theory_results.ipynb | christopherkullenberg/KT2102Evaluations | dbd7789de37268e8240091609a1115019940879c | [
"MIT"
] | null | null | null | 50.677149 | 4,600 | 0.663137 | [
[
[
"import pandas as pd\nfrom collections import Counter",
"_____no_output_____"
]
],
[
[
"## Survey 1, Theory\n\n**Coding**\n\n*1. Vilket/vilka moment upplevde du vara svårast i Inlämningsuppgift 1? Ange korta nyckelord, ex. \"litteraturen\", \"föreläsningarna\", osv.*\n\n str\n\n*2. Vilka insikter/kunskaper upplever du att du fått under de teoretiska momenten? Ange korta nyckelord.*\n\n str\n\n*3. Upplevde du att du hade all information som krävdes för att lösa inlämningsuppgift 1? Om inte, vilken information tycker du saknades?*7\n\n str\n\n*4. Hur relevant upplever du att de teoretiska momenten var för kursen Kommunikation i nya och sociala medier? Ringa in en siffra på skalan 0-10 (0-inte alls relevant, 10-mycket relevant)*\n\n int 0-10\n\n*5. Hur relevant upplever du att de teoretiska momenten var för yrkesrollen kommunikatör i offentlig förvaltning? Ringa in en siffra på skalan 0-10 (0-inte alls relevant, 10-mycket relevant)*\n\n int 0-10\n \n\nThe scanned questionnaires can be found on [https://github.com/christopherkullenberg/KT2102Evaluations/tree/master/raw_survey_data/Survey1Theory](https://github.com/christopherkullenberg/KT2102Evaluations/tree/master/raw_survey_data/Survey1Theory)",
"_____no_output_____"
]
],
[
[
"df1 = pd.read_csv(\"data/survey_theory.csv\")\nprint(\"N =\", str(len(df1)))",
"N = 17\n"
],
[
"df1.head()",
"_____no_output_____"
],
[
"Q1results = []\n\nprint(\"Showing results for: \")\nprint(\"Vilket/vilka moment upplevde du vara svårast i Inlämningsuppgift 1?\")\nfor row in df1.iloc[:, 1:4]:\n print(row)\n for n in df1[row]:\n if type(n) == str:\n Q1results.append(n)\n \nprint(\"\\nResult: \", Q1results)\nprint(\"\\nKeyword frequencies:\")\nfor freq in Counter(Q1results).most_common():\n print(freq[0], \" - \", freq[1])",
"Showing results for: \nVilket/vilka moment upplevde du vara svårast i Inlämningsuppgift 1?\nQ1A\nQ1B\nQ1C\n\nResult: ['hålla det kort', 'föreläsningar svävande', 'formulera fråga', 'artiklarna', 'källhänvisningar', 'hålla det kort', 'beskrivning av uppgift', 'artiklarna', 'upplägget', 'begrepp', 'nivå', 'litteratur', 'exemplifiera', 'hålla det kort', 'litteratur', 'välja fråga', 'hinna med att läsa', 'exemplifiera', 'hålla det kort', 'akademisk nivå', 'litteratur', 'hålla det kort', 'svårt att hitta djup I litteratur', 'målgrupp', 'stor valfrihet']\n\nKeyword frequencies:\nhålla det kort - 5\nlitteratur - 3\nartiklarna - 2\nexemplifiera - 2\nföreläsningar svävande - 1\nformulera fråga - 1\nkällhänvisningar - 1\nbeskrivning av uppgift - 1\nupplägget - 1\nbegrepp - 1\nnivå - 1\nvälja fråga - 1\nhinna med att läsa - 1\nakademisk nivå - 1\nsvårt att hitta djup I litteratur - 1\nmålgrupp - 1\nstor valfrihet - 1\n"
],
[
"Q2results = []\n\nprint(\"Showing results for: \")\nprint(\"Vilka insikter/kunskaper upplever du att du fått under de teoretiska momenten?\")\nfor row in df1.iloc[:, 4:7]:\n print(row)\n for n in df1[row]:\n if type(n) == str:\n Q2results.append(n)\n \nprint(\"\\nResult: \", Q2results)\nprint(\"\\nKeyword frequencies:\")\nfor freq in Counter(Q2results).most_common():\n print(freq[0], \" - \", freq[1])",
"Showing results for: \nVilka insikter/kunskaper upplever du att du fått under de teoretiska momenten?\nQ2A\nQ2B\nQ2C\n\nResult: ['begrepp', 'begrepp', 'förankring I forskning', 'begrepp', 'sociala medier I organisationer', 'digitalt samhälle', 'begrepp', 'perspektiv', 'anpassning till teknologi', 'begrepp', 'förståelse', 'digitalt samhälle', 'begrepp', 'insikt I huvudämnet', 'digitalt samhälle', 'Lindgrens bok', 'digital forskning', 'fördelar och nackdelar med sociala medier', 'kommunikation I sociala medier', 'samverkan teknik och människa', 'källhänvisningar', 'hur man påverkas av sociala medier', 'perspektiv', 'perspektiv', 'seminarium', 'förståelse för forskning']\n\nKeyword frequencies:\nbegrepp - 6\ndigitalt samhälle - 3\nperspektiv - 3\nförankring I forskning - 1\nsociala medier I organisationer - 1\nanpassning till teknologi - 1\nförståelse - 1\ninsikt I huvudämnet - 1\nLindgrens bok - 1\ndigital forskning - 1\nfördelar och nackdelar med sociala medier - 1\nkommunikation I sociala medier - 1\nsamverkan teknik och människa - 1\nkällhänvisningar - 1\nhur man påverkas av sociala medier - 1\nseminarium - 1\nförståelse för forskning - 1\n"
],
[
"Q3results = []\n\nprint(\"Showing results for: \")\nprint(\"Upplevde du att du hade all information som krävdes för att lösa inlämningsuppgift 1?\")\nfor row in df1.iloc[:, 7:10]:\n print(row)\n for n in df1[row]:\n if type(n) == str:\n Q3results.append(n)\n \nprint(\"\\nResult: \", Q3results)\nprint(\"\\nKeyword frequencies:\")\nfor freq in Counter(Q3results).most_common():\n print(freq[0], \" - \", freq[1])",
"Showing results for: \nUpplevde du att du hade all information som krävdes för att lösa inlämningsuppgift 1?\nQ3A\nQ3B\nQ3C\n\nResult: ['ja', 'källhänvisningar', 'ja', 'ja', 'tydlig information om examination', 'källhänvisningar', 'ja', 'ja', 'tidsbrist på föreläsningar', 'oklart om exemplifiering', 'ja', 'ja', 'ja', 'ja', 'antal tecken ospecificerat', 'mer info om föreläsningar', 'ja', 'oklart om målgrupp', 'mer genomgång av begrepp']\n\nKeyword frequencies:\nja - 10\nkällhänvisningar - 2\ntydlig information om examination - 1\ntidsbrist på föreläsningar - 1\noklart om exemplifiering - 1\nantal tecken ospecificerat - 1\nmer info om föreläsningar - 1\noklart om målgrupp - 1\nmer genomgång av begrepp - 1\n"
],
[
"print(\"Hur relevant upplever du att de teoretiska momenten var för kursen Kommunikation i nya och sociala medier?\")\ndf1.Q4.value_counts().plot.bar(x=\"Score\", rot=0, subplots=True)\nprint(\"Mean = \" + str(df1.Q4.mean()))\nprint(\"Median = \" + str(df1.Q4.median()))\nprint(\"Std = \" + str(df1.Q4.std()))",
"Hur relevant upplever du att de teoretiska momenten var för kursen Kommunikation i nya och sociala medier?\nMean = 9.352941176470589\nMedian = 10.0\nStd = 0.9963167462326074\n"
],
[
"print(\"Hur relevant upplever du att de teoretiska momenten var för yrkesrollen kommunikatör i offentlig förvaltning?\")\ndf1.Q5.value_counts().plot.bar(x=\"Score\", rot=0, subplots=True)\nprint(\"Mean = \" + str(df1.Q5.mean()))\nprint(\"Median = \" + str(df1.Q5.median()))\nprint(\"Std = \" + str(df1.Q5.std()))",
"Hur relevant upplever du att de teoretiska momenten var för yrkesrollen kommunikatör i offentlig förvaltning?\nMean = 8.764705882352942\nMedian = 10.0\nStd = 1.8550408272025267\n"
]
]
] | [
"code",
"markdown",
"code"
] | [
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
eceb2bd6750c94f4db2d8b51baef2992b1e37c27 | 70,366 | ipynb | Jupyter Notebook | python-for-data-visualization-projects/geographical-plotting/.ipynb_checkpoints/Choropleth Maps-checkpoint.ipynb | niccololampa/data-science-projects | f1d7c208ad59c5e54614af17210cad997bb6fee5 | [
"MIT"
] | null | null | null | python-for-data-visualization-projects/geographical-plotting/.ipynb_checkpoints/Choropleth Maps-checkpoint.ipynb | niccololampa/data-science-projects | f1d7c208ad59c5e54614af17210cad997bb6fee5 | [
"MIT"
] | null | null | null | python-for-data-visualization-projects/geographical-plotting/.ipynb_checkpoints/Choropleth Maps-checkpoint.ipynb | niccololampa/data-science-projects | f1d7c208ad59c5e54614af17210cad997bb6fee5 | [
"MIT"
] | null | null | null | 43.302154 | 7,472 | 0.470682 | [
[
[
"___\n\n<a href='http://www.pieriandata.com'> <img src='../Pierian_Data_Logo.png' /></a>\n___",
"_____no_output_____"
],
[
"# Choropleth Maps",
"_____no_output_____"
],
[
"Focus will be on plotly for plotting\n\nBUt matplotlib has a basemap extension which provides for static plotting. ",
"_____no_output_____"
],
[
"## Offline Plotly Usage",
"_____no_output_____"
],
[
"Get imports and set everything up to be working offline.",
"_____no_output_____"
]
],
[
[
"import plotly.plotly as py\nimport plotly.graph_objs as go \nfrom plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot #tobe able to do it offline. ",
"_____no_output_____"
]
],
[
[
"Now set up everything so that the figures show up in the notebook:",
"_____no_output_____"
]
],
[
[
"init_notebook_mode(connected=True) #to see everything in the notebook. ",
"_____no_output_____"
]
],
[
[
"More info on other options for Offline Plotly usage can be found [here](https://plot.ly/python/offline/).",
"_____no_output_____"
],
[
"https://plot.ly/python/reference/#choropleth #reference",
"_____no_output_____"
],
[
"## Choropleth US Maps\n\nPlotly's mapping can be a bit hard to get used to at first, remember to reference the cheat sheet in the data visualization folder, or [find it online here](https://images.plot.ly/plotly-documentation/images/python_cheat_sheet.pdf).",
"_____no_output_____"
]
],
[
[
"import pandas as pd #important to see cheat sheet above link. ",
"_____no_output_____"
]
],
[
[
"Now we need to begin to build our data dictionary. Easiest way to do this is to use the **dict()** function of the general form:\n\n* type = 'choropleth',\n* locations = list of states\n* locationmode = 'USA-states'\n* colorscale= \n\nEither a predefined string:\n\n 'pairs' | 'Greys' | 'Greens' | 'Bluered' | 'Hot' | 'Picnic' | 'Portland' | 'Jet' | 'RdBu' | 'Blackbody' | 'Earth' | 'Electric' | 'YIOrRd' | 'YIGnBu'\n\nor create a [custom colorscale](https://plot.ly/python/heatmap-and-contour-colorscales/)\n\n* text= list or array of text to display per point\n* z= array of values on z axis (color of state)\n* colorbar = {'title':'Colorbar Title'})\n\nHere is a simple example:",
"_____no_output_____"
]
],
[
[
"data = dict(type = 'choropleth', #clarifies which type of geogrhapical plot we are doing. \n locations = ['AZ','CA','NY'], # actual abbreviation of states since we are doing this only on a nationwide scale. \n locationmode = 'USA-states', # essential. let's plotly know that we are doing this on a US location level. check documentation. This can go down into county level. Check documentation. \n colorscale= 'Portland', #can change the coloring style\n text= ['text1','text2','text3'], #text is what shows when mouse hovers on a particular location in graph.\n z=[1.0,2.0,3.0], #z actual values that will be shown in the color scale. \n colorbar = {'title':'Colorbar Title'}) #colorbar config here it is jsut the title. \n\n\n#documentattion likes to call dict rather than typing the actual dictionary to save time. ",
"_____no_output_____"
],
[
"data #preview of data",
"_____no_output_____"
]
],
[
[
"Then we create the layout nested dictionary:",
"_____no_output_____"
]
],
[
[
"layout = dict(geo = {'scope':'usa'})",
"_____no_output_____"
]
],
[
[
"Then we use: \n\n go.Figure(data = [data],layout = layout)\n \nto set up the object that finally gets passed into iplot()",
"_____no_output_____"
]
],
[
[
"choromap = go.Figure(data = [data],layout = layout)",
"_____no_output_____"
],
[
"iplot(choromap)\n\n#if you use plot(choromap) instead it will open in a new tab as an html where you can save it as png etc. ",
"_____no_output_____"
]
],
[
[
"### Real Data US Map Choropleth\n\nNow let's show an example with some real data as well as some other options we can add to the dictionaries in data and layout.",
"_____no_output_____"
]
],
[
[
"df = pd.read_csv('2011_US_AGRI_Exports')\ndf.head()",
"_____no_output_____"
]
],
[
[
"Now out data dictionary with some extra marker and colorbar arguments:",
"_____no_output_____"
]
],
[
[
"data = dict(type='choropleth',\n colorscale = 'YIOrRd',\n locations = df['code'], #referencing a column in a dataframe. list of state codes. \n z = df['total exports'],\n locationmode = 'USA-states',\n text = df['text'],\n marker = dict(line = dict(color = 'rgb(255,255,255)',width = 2)), #space width between the states and the color. \n colorbar = {'title':\"Millions USD\"}\n ) ",
"_____no_output_____"
]
],
[
[
"And our layout dictionary with some more arguments:",
"_____no_output_____"
]
],
[
[
"layout = dict(title = '2011 US Agriculture Exports by State', # you can set the ttitle. \n geo = dict(scope='usa',\n showlakes = True, #you can add to show lakes (optional)\n lakecolor = 'rgb(85,173,240)') #color of the lakes (optional)\n )",
"_____no_output_____"
],
[
"choromap = go.Figure(data = [data],layout = layout)",
"_____no_output_____"
],
[
"iplot(choromap)",
"_____no_output_____"
]
],
[
[
"# World Choropleth Map\n\nNow let's see an example with a World Map:",
"_____no_output_____"
]
],
[
[
"df = pd.read_csv('2014_World_GDP')\ndf.head()",
"_____no_output_____"
],
[
"data = dict(\n type = 'choropleth',\n locations = df['CODE'],\n z = df['GDP (BILLIONS)'],\n text = df['COUNTRY'],\n colorbar = {'title' : 'GDP Billions US'},\n ) ",
"_____no_output_____"
],
[
"layout = dict(\n title = '2014 Global GDP',\n geo = dict(\n showframe = False, # for world no scope were passed unlike above\n projection = {'type':'Mercator'} #reference the documentation for the projection type. For now mercator was used for map graph. \n )\n)",
"_____no_output_____"
],
[
"choromap = go.Figure(data = [data],layout = layout)\niplot(choromap)",
"_____no_output_____"
]
],
[
[
"# Great Job!",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
],
[
"markdown"
]
] |
eceb34feb76f8498a804b6be5dac404077dea5d7 | 27,081 | ipynb | Jupyter Notebook | notebooks/scratch03-essentiality_range.ipynb | pritchardlabatpsu/cga | 0a71c672b1348cebc724560643fd908d636fc133 | [
"MIT"
] | null | null | null | notebooks/scratch03-essentiality_range.ipynb | pritchardlabatpsu/cga | 0a71c672b1348cebc724560643fd908d636fc133 | [
"MIT"
] | null | null | null | notebooks/scratch03-essentiality_range.ipynb | pritchardlabatpsu/cga | 0a71c672b1348cebc724560643fd908d636fc133 | [
"MIT"
] | 1 | 2022-02-08T01:06:20.000Z | 2022-02-08T01:06:20.000Z | 45.822335 | 12,488 | 0.705513 | [
[
[
"Getting processed genomic/ceres datasets",
"_____no_output_____"
]
],
[
[
"import pickle\nimport sys\nimport pandas as pd\nimport seaborn as sns\nimport matplotlib.pyplot as plt",
"_____no_output_____"
],
[
"dm_data = pickle.load(open('../out/20.0817 proc_data/gene_effect/dm_data.pkl','rb'))",
"_____no_output_____"
],
[
"dm_data.df_crispr.to_csv('ceres_processed.csv') # for analyses in R later",
"_____no_output_____"
],
[
"#get gene names\ndm_data.df_crispr.columns = dm_data.df_crispr.columns.str.extract('^(.*)\\s\\(').squeeze().values",
"_____no_output_____"
],
[
"df = dm_data.df_crispr",
"_____no_output_____"
],
[
"df_genedep = pd.read_csv('%s/%s' % (dm_data.dir_datasets, dm_data.fname_gene_dependency), header=0, index_col=0)\ndf_genedep.columns = df_genedep.columns.str.extract('^(.*)\\s').squeeze().values",
"_____no_output_____"
],
[
"# get which ones are selective essential, and which ones are common essential, common nonessential\ndef classifyDep(x):\n if all(x>0.5):\n return 'common_essential'\n elif all(x<0.5):\n return 'common_nonessential'\n else:\n return 'selective_essential'\n\ndep_class = df_genedep.apply(lambda x: classifyDep(x), axis=0)",
"_____no_output_____"
],
[
"dep_class.to_csv('ceres_class.csv') # for analyses in R later",
"_____no_output_____"
],
[
"df_common_essential = df.loc[:,df.columns.isin(dep_class[dep_class=='common_essential'].index)]\ndf_common_nonessential = df.loc[:,df.columns.isin(dep_class[dep_class=='common_nonessential'].index)]\ndf_selective_essential = df.loc[:,df.columns.isin(dep_class[dep_class=='selective_essential'].index)]",
"_____no_output_____"
],
[
"df1 = -1*df_common_essential.kurtosis()\ndf1.name = 'neg_kurtosis'\ndf2 = (df_common_essential.max()-df_common_essential.min())\ndf2.name = 'range'\ndf3 = pd.merge(df1,df2, left_index=True, right_index=True)",
"_____no_output_____"
],
[
"df3.sort_values(['range', 'neg_kurtosis'])",
"_____no_output_____"
],
[
"# common essential, high kurtosis\ndf_common_essential.kurtosis().sort_values()[-5:]",
"_____no_output_____"
],
[
"# common essential, low kurtosis\ndf_common_essential.kurtosis().sort_values()[:5]",
"_____no_output_____"
],
[
"# common selective-essential, high kurtosis\ndf_selective_essential.kurtosis().sort_values()[-5:]",
"_____no_output_____"
],
[
"# common selective-essential, low kurtosis\ndf_selective_essential.kurtosis().sort_values()[:5]",
"_____no_output_____"
],
[
"# common essential, high range\n(df_common_essential.max()-df_common_essential.min()).sort_values()[-5:]",
"_____no_output_____"
],
[
"# common essential, tight range\n(df_common_essential.max()-df_common_essential.min()).sort_values()[:5]",
"_____no_output_____"
],
[
"# common selective-essential, high range\n(df_selective_essential.max()-df_selective_essential.min()).sort_values()[-5:]",
"_____no_output_____"
],
[
"# common selective-essential, tight range\n(df_selective_essential.max()-df_selective_essential.min()).sort_values()[:5]",
"_____no_output_____"
],
[
"sns.distplot(df_range_merged.range)",
"_____no_output_____"
],
[
"df_range = (df_selective_essential.max()-df_selective_essential.min())\ndf_range.name = 'range'\ndep_class.name = 'dep_class'\ndf_range_merged = pd.merge(df_range,dep_class, left_index=True, right_index=True)",
"_____no_output_____"
],
[
"sns.distplot(data=df_range_merged, x='range', hue='dep_class')",
"_____no_output_____"
]
]
] | [
"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"
]
] |
eceb39ba77c64ca784232e2c7bdbf5509f4ccc5a | 806,753 | ipynb | Jupyter Notebook | codici/mnist_keras.ipynb | tvml/ml2021 | d72a6762af9cd12019d87237d061bbb39f560da9 | [
"MIT"
] | null | null | null | codici/mnist_keras.ipynb | tvml/ml2021 | d72a6762af9cd12019d87237d061bbb39f560da9 | [
"MIT"
] | null | null | null | codici/mnist_keras.ipynb | tvml/ml2021 | d72a6762af9cd12019d87237d061bbb39f560da9 | [
"MIT"
] | null | null | null | 264.943514 | 367,438 | 0.888687 | [
[
[
"%tensorflow_version 2.x",
"_____no_output_____"
],
[
"%matplotlib inline\nimport pandas as pd\nimport numpy as np\nimport matplotlib.pyplot as plt\nfrom pylab import subplot,imshow,title,gray,NullLocator\nimport scipy.misc as mi\nimport scipy.special as sp\nfrom PIL import Image\nfrom itertools import chain\nfrom sklearn.metrics import confusion_matrix, accuracy_score, precision_recall_fscore_support\n\nfrom keras.datasets import mnist\nfrom keras.models import Sequential\nfrom keras.layers.core import Dense, Dropout, Activation\nfrom keras.utils import np_utils\nfrom keras.models import model_from_json\n\nfrom keras.layers import Flatten\nfrom keras.layers.convolutional import Conv2D\nfrom keras.layers.convolutional import MaxPooling2D\nfrom keras.utils import np_utils\nfrom keras import backend as K",
"_____no_output_____"
],
[
"from google.colab import drive\ndrive.mount('/gdrive')",
"Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly\n\nEnter your authorization code:\n··········\nMounted at /gdrive\n"
],
[
"# visualizza dati\ndef displayData(X, t, rows=10, cols=10, img_ind=None, size =16, class_value = False):\n if len(X)>rows*cols:\n img_ind = np.random.permutation(len(X))[0:rows * cols]\n else:\n img_ind = range(rows*cols)\n fig = plt.figure(figsize = (size,size))\n fig.patch.set_facecolor('white')\n ax = fig.gca()\n for i in range(100):\n plt.subplot(10,10,i+1)\n plt.imshow([255-x for x in X[img_ind[i]]], cmap='gray', interpolation='gaussian')\n if class_value:\n plt.title(\"{}\".format(t[img_ind[i]]),fontsize = 16, color='b')\n plt.gca().xaxis.set_major_locator(plt.NullLocator())\n plt.gca().yaxis.set_major_locator(plt.NullLocator())\n plt.axis('off')\n plt.subplots_adjust(top=1)\n plt.show()",
"_____no_output_____"
],
[
"def plotData(X, Y, c, npixel=28):\n m, n = X.shape\n image = np.array(X[c,:])\n plt.figure(figsize = (6,6))\n plt.imshow((image.reshape(npixel, npixel)), cmap='Greys', interpolation='quadric')\n plt.show()",
"_____no_output_____"
],
[
"def plotAccuracy(acc_history_train, acc_history_test):\n plt.figure(figsize = (12,8))\n plt.plot(acc_history_train, marker='o', markersize=5, label='Train')\n plt.plot(acc_history_test, marker='o', markersize=5, label='Test')\n plt.legend()\n plt.gca().xaxis.set_major_locator(plt.NullLocator())\n plt.show()",
"_____no_output_____"
],
[
"def save_model(m,filename):\n model_json = m.to_json()\n with open(\"/gdrive/My Drive/colab_data/\"+filename+\".json\", \"w\") as json_file:\n json_file.write(model_json)\n # serialize weights to HDF5\n m.save_weights(\"/gdrive/My Drive/colab_data/\"+filename+\".h5\")\n print(\"Saved model to disk\")",
"_____no_output_____"
],
[
"def load_model_weights(filename, model):\n model.load_weights(\"/gdrive/My Drive/colab_data/\"+filename+\".h5\")\n print(\"Loaded weights from disk\")\n return model",
"_____no_output_____"
],
[
"def load_model(filename):\n json_file = open(\"/gdrive/My Drive/colab_data/\"+filename+'.json', 'r')\n loaded_model_json = json_file.read()\n json_file.close()\n m = model_from_json(loaded_model_json)\n # load weights into new model\n m.load_weights(\"/gdrive/My Drive/colab_data/\"+filename+\".h5\")\n print(\"Loaded model from disk\")\n return m",
"_____no_output_____"
]
],
[
[
"Fissa il numero di classi pari a 10 (corrispondenti alle cifre 0,1,...,9) e leggi i dati, suddivisi in training e test set, $(X_{train}, t_{train}), (X_{test}, t_{test})$. Le matrici $X$ rappresentano le immagini, mentre i vettori $t$ specificano le relative classi.",
"_____no_output_____"
]
],
[
[
"nb_classes = 10\n\n(X_train, t_train), (X_test, t_test) = mnist.load_data()",
"Downloading data from https://s3.amazonaws.com/img-datasets/mnist.npz\n11493376/11490434 [==============================] - 0s 0us/step\n"
],
[
"X_train.shape, X_test.shape",
"_____no_output_____"
]
],
[
[
"Visualizza la dimensione di $X_{train}$ e $X_{test}$. Le immagini rappresentate risultano indicizzate dalla prima dimensione e definite come matrici $28\\times 28$. I valori nelle matrici sono interi compresi tra $0$ e $255$.\n",
"_____no_output_____"
]
],
[
[
"X_train[0,:,:]",
"_____no_output_____"
]
],
[
[
"Esempio: i primi 100 elementi nel training set con la relativa classe",
"_____no_output_____"
]
],
[
[
"displayData(X_train[0:100], t_train[0:100], class_value=True)",
"_____no_output_____"
]
],
[
[
"Modifica la rappresentazione degli elementi da matrici $28\\times 28$ a vettori di dimensione $784$, con elementi reali compresi tra $0$ e $1$.",
"_____no_output_____"
]
],
[
[
"X_train = X_train.reshape(X_train.shape[0], 784)\nX_test = X_test.reshape(X_test.shape[0], 784)\nX_train = X_train.astype('float32')\nX_test = X_test.astype('float32')\nX_train /= 255\nX_test /= 255",
"_____no_output_____"
],
[
"X_train[0,:].shape",
"_____no_output_____"
]
],
[
[
"Le classi vengono codificate nella forma $\\textit{one-hot}$, come vettori di dimensione $10$ (il numero delle classi) con elementi pari a $0$, eccetto quello di indice pari al valore da codificare.\n",
"_____no_output_____"
]
],
[
[
"T_train = np_utils.to_categorical(t_train, nb_classes)\nT_test = np_utils.to_categorical(t_test, nb_classes)",
"_____no_output_____"
],
[
"t_train[0:5]",
"_____no_output_____"
],
[
"T_train[0:5,:]",
"_____no_output_____"
]
],
[
[
"Costruisci il modello (insieme delle possibili funzioni)",
"_____no_output_____"
]
],
[
[
"# softmax regression\nmodel0 = Sequential()\nmodel0.add(Dense(10, input_shape=(784,)))\nmodel0.add(Activation('softmax'))\nmodel0.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='sgd')",
"_____no_output_____"
],
[
"model0.summary()",
"Model: \"sequential_2\"\n_________________________________________________________________\nLayer (type) Output Shape Param # \n=================================================================\ndense_2 (Dense) (None, 10) 7850 \n_________________________________________________________________\nactivation_2 (Activation) (None, 10) 0 \n=================================================================\nTotal params: 7,850\nTrainable params: 7,850\nNon-trainable params: 0\n_________________________________________________________________\n"
],
[
"#model0 = load_model_weights('softmax', model0)",
"_____no_output_____"
]
],
[
[
"Cerca la migliore funzione possibile, rispetto ai dati disponibili",
"_____no_output_____"
]
],
[
[
"history0 = model0.fit(X_train, T_train, batch_size=128, epochs=50, verbose=1, validation_data=(X_test, T_test))",
"Train on 60000 samples, validate on 10000 samples\nEpoch 1/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.3090 - accuracy: 0.9139 - val_loss: 0.2978 - val_accuracy: 0.9178\nEpoch 2/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.3082 - accuracy: 0.9144 - val_loss: 0.2972 - val_accuracy: 0.9173\nEpoch 3/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.3075 - accuracy: 0.9146 - val_loss: 0.2964 - val_accuracy: 0.9181\nEpoch 4/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.3068 - accuracy: 0.9147 - val_loss: 0.2960 - val_accuracy: 0.9173\nEpoch 5/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.3061 - accuracy: 0.9148 - val_loss: 0.2954 - val_accuracy: 0.9170\nEpoch 6/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.3055 - accuracy: 0.9148 - val_loss: 0.2952 - val_accuracy: 0.9179\nEpoch 7/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.3048 - accuracy: 0.9153 - val_loss: 0.2943 - val_accuracy: 0.9176\nEpoch 8/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.3042 - accuracy: 0.9152 - val_loss: 0.2941 - val_accuracy: 0.9176\nEpoch 9/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.3036 - accuracy: 0.9154 - val_loss: 0.2933 - val_accuracy: 0.9174\nEpoch 10/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.3030 - accuracy: 0.9157 - val_loss: 0.2929 - val_accuracy: 0.9180\nEpoch 11/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.3024 - accuracy: 0.9157 - val_loss: 0.2925 - val_accuracy: 0.9181\nEpoch 12/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.3018 - accuracy: 0.9159 - val_loss: 0.2922 - val_accuracy: 0.9186\nEpoch 13/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.3013 - accuracy: 0.9159 - val_loss: 0.2919 - val_accuracy: 0.9184\nEpoch 14/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.3007 - accuracy: 0.9163 - val_loss: 0.2913 - val_accuracy: 0.9181\nEpoch 15/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.3002 - accuracy: 0.9165 - val_loss: 0.2906 - val_accuracy: 0.9187\nEpoch 16/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2997 - accuracy: 0.9165 - val_loss: 0.2905 - val_accuracy: 0.9187\nEpoch 17/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.2992 - accuracy: 0.9168 - val_loss: 0.2902 - val_accuracy: 0.9185\nEpoch 18/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.2987 - accuracy: 0.9167 - val_loss: 0.2900 - val_accuracy: 0.9192\nEpoch 19/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.2982 - accuracy: 0.9168 - val_loss: 0.2897 - val_accuracy: 0.9185\nEpoch 20/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.2977 - accuracy: 0.9171 - val_loss: 0.2892 - val_accuracy: 0.9191\nEpoch 21/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.2972 - accuracy: 0.9170 - val_loss: 0.2888 - val_accuracy: 0.9191\nEpoch 22/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.2968 - accuracy: 0.9176 - val_loss: 0.2885 - val_accuracy: 0.9198\nEpoch 23/50\n60000/60000 [==============================] - 1s 17us/step - loss: 0.2964 - accuracy: 0.9176 - val_loss: 0.2880 - val_accuracy: 0.9191\nEpoch 24/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.2959 - accuracy: 0.9178 - val_loss: 0.2877 - val_accuracy: 0.9197\nEpoch 25/50\n60000/60000 [==============================] - 1s 17us/step - loss: 0.2955 - accuracy: 0.9177 - val_loss: 0.2878 - val_accuracy: 0.9192\nEpoch 26/50\n60000/60000 [==============================] - 1s 21us/step - loss: 0.2951 - accuracy: 0.9179 - val_loss: 0.2871 - val_accuracy: 0.9198\nEpoch 27/50\n60000/60000 [==============================] - 1s 20us/step - loss: 0.2946 - accuracy: 0.9178 - val_loss: 0.2873 - val_accuracy: 0.9196\nEpoch 28/50\n60000/60000 [==============================] - 1s 20us/step - loss: 0.2942 - accuracy: 0.9178 - val_loss: 0.2869 - val_accuracy: 0.9195\nEpoch 29/50\n60000/60000 [==============================] - 1s 18us/step - loss: 0.2938 - accuracy: 0.9181 - val_loss: 0.2866 - val_accuracy: 0.9198\nEpoch 30/50\n60000/60000 [==============================] - 1s 18us/step - loss: 0.2934 - accuracy: 0.9182 - val_loss: 0.2861 - val_accuracy: 0.9199\nEpoch 31/50\n60000/60000 [==============================] - 1s 18us/step - loss: 0.2930 - accuracy: 0.9181 - val_loss: 0.2859 - val_accuracy: 0.9196\nEpoch 32/50\n60000/60000 [==============================] - 1s 18us/step - loss: 0.2927 - accuracy: 0.9184 - val_loss: 0.2856 - val_accuracy: 0.9199\nEpoch 33/50\n60000/60000 [==============================] - 1s 19us/step - loss: 0.2923 - accuracy: 0.9186 - val_loss: 0.2851 - val_accuracy: 0.9202\nEpoch 34/50\n60000/60000 [==============================] - 1s 18us/step - loss: 0.2920 - accuracy: 0.9183 - val_loss: 0.2852 - val_accuracy: 0.9205\nEpoch 35/50\n60000/60000 [==============================] - 1s 18us/step - loss: 0.2916 - accuracy: 0.9187 - val_loss: 0.2850 - val_accuracy: 0.9199\nEpoch 36/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.2912 - accuracy: 0.9189 - val_loss: 0.2847 - val_accuracy: 0.9205\nEpoch 37/50\n60000/60000 [==============================] - 1s 16us/step - loss: 0.2909 - accuracy: 0.9190 - val_loss: 0.2844 - val_accuracy: 0.9204\nEpoch 38/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2906 - accuracy: 0.9191 - val_loss: 0.2843 - val_accuracy: 0.9200\nEpoch 39/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2902 - accuracy: 0.9192 - val_loss: 0.2839 - val_accuracy: 0.9204\nEpoch 40/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2899 - accuracy: 0.9191 - val_loss: 0.2836 - val_accuracy: 0.9211\nEpoch 41/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2896 - accuracy: 0.9191 - val_loss: 0.2835 - val_accuracy: 0.9207\nEpoch 42/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2893 - accuracy: 0.9194 - val_loss: 0.2835 - val_accuracy: 0.9200\nEpoch 43/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2889 - accuracy: 0.9194 - val_loss: 0.2829 - val_accuracy: 0.9207\nEpoch 44/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2886 - accuracy: 0.9199 - val_loss: 0.2828 - val_accuracy: 0.9201\nEpoch 45/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2883 - accuracy: 0.9200 - val_loss: 0.2827 - val_accuracy: 0.9207\nEpoch 46/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2880 - accuracy: 0.9198 - val_loss: 0.2825 - val_accuracy: 0.9211\nEpoch 47/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2877 - accuracy: 0.9199 - val_loss: 0.2823 - val_accuracy: 0.9208\nEpoch 48/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2874 - accuracy: 0.9202 - val_loss: 0.2821 - val_accuracy: 0.9207\nEpoch 49/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2872 - accuracy: 0.9202 - val_loss: 0.2820 - val_accuracy: 0.9210\nEpoch 50/50\n60000/60000 [==============================] - 1s 15us/step - loss: 0.2868 - accuracy: 0.9206 - val_loss: 0.2818 - val_accuracy: 0.9210\n"
],
[
"save_model(model0, 'softmax')",
"Saved model to disk\n"
],
[
"history0_df = pd.DataFrame(history0.history)",
"_____no_output_____"
],
[
"history0_df.head()",
"_____no_output_____"
],
[
"save_model(model0,'softmax')",
"Saved model to disk\n"
]
],
[
[
"Accuracy: frazione di risposte corrette",
"_____no_output_____"
]
],
[
[
"plotAccuracy(history0_df.accuracy, history0_df.val_accuracy)",
"_____no_output_____"
],
[
"predictions_train = model0.predict_classes(X_train, verbose=0)",
"_____no_output_____"
],
[
"confusion_matrix(t_train, predictions_train)",
"_____no_output_____"
],
[
"accuracy_score(t_train, predictions_train)",
"_____no_output_____"
],
[
"meas = precision_recall_fscore_support(t_train, predictions_train, average=None)\nprint('Training set')\nfor i in range(10):\n print('Class {0:d}: precision={1:5.2f}, recall={2:5.2f}, f-measure={2:5.2f}'.format(i, meas[1][i], meas[2][i], meas[3][i]))",
"Training set\nClass 0: precision= 0.97, recall= 0.96, f-measure= 0.96\nClass 1: precision= 0.97, recall= 0.96, f-measure= 0.96\nClass 2: precision= 0.89, recall= 0.91, f-measure= 0.91\nClass 3: precision= 0.89, recall= 0.90, f-measure= 0.90\nClass 4: precision= 0.93, recall= 0.93, f-measure= 0.93\nClass 5: precision= 0.87, recall= 0.88, f-measure= 0.88\nClass 6: precision= 0.96, recall= 0.95, f-measure= 0.95\nClass 7: precision= 0.93, recall= 0.93, f-measure= 0.93\nClass 8: precision= 0.88, recall= 0.89, f-measure= 0.89\nClass 9: precision= 0.90, recall= 0.90, f-measure= 0.90\n"
],
[
"predictions_test = model0.predict_classes(X_test, verbose=0)",
"_____no_output_____"
],
[
"confusion_matrix(t_test, predictions_test)",
"_____no_output_____"
],
[
"accuracy_score(t_test, predictions_test)",
"_____no_output_____"
],
[
"meas = precision_recall_fscore_support(t_test, predictions_test, average=None)\nprint('Test set')\nfor i in range(10):\n print('Class {0:d}: precision={1:5.2f}, recall={2:5.2f}, f-measure={2:5.2f}'.format(i, meas[1][i], meas[2][i], meas[3][i]))",
"Test set\nClass 0: precision= 0.98, recall= 0.96, f-measure= 0.96\nClass 1: precision= 0.98, recall= 0.97, f-measure= 0.97\nClass 2: precision= 0.89, recall= 0.91, f-measure= 0.91\nClass 3: precision= 0.91, recall= 0.90, f-measure= 0.90\nClass 4: precision= 0.93, recall= 0.92, f-measure= 0.92\nClass 5: precision= 0.86, recall= 0.88, f-measure= 0.88\nClass 6: precision= 0.95, recall= 0.94, f-measure= 0.94\nClass 7: precision= 0.92, recall= 0.92, f-measure= 0.92\nClass 8: precision= 0.89, recall= 0.89, f-measure= 0.89\nClass 9: precision= 0.89, recall= 0.90, f-measure= 0.90\n"
],
[
"w0 = model0.layers[0].get_weights()\nw = w0[0]",
"_____no_output_____"
],
[
"w0[1]",
"_____no_output_____"
],
[
"fig = plt.figure(figsize=(16,16))\nfig.patch.set_facecolor('white')\nfor i in range(10):\n ax = subplot(2,5,i+1,frame_on=False, facecolor=\"#F8F8F8\")\n ax.xaxis.set_major_locator(NullLocator())\n ax.yaxis.set_major_locator(NullLocator())\n imshow(w[:,i].reshape(28,28), interpolation='quadric', \n cmap=plt.get_cmap('Greys'), vmin=np.mean(w[:,i])-3.5*np.std(w[:,i]), \n vmax=np.mean(w[:,i])+3.5*np.std(w[:,i]), aspect='auto')\n plt.title(i)\nplt.subplots_adjust(top=0.4)\nplt.show()",
"_____no_output_____"
],
[
"c = np.random.randint(0, X_test.shape[0])\np=model0.predict_classes(X_test[c:c+1,:], verbose=0)\nprint(\"Elemento \"+str(c))\nplotData(X_test, t_test, c)\nprint(\"Un \"+str(t_test[c])+\", classificato come \" + str(p[0]))",
"Elemento 7917\n"
],
[
"# 3 layer NN\nmodel1 = Sequential()\nmodel1.add(Dense(512, input_shape=(784,)))\nmodel1.add(Activation('relu'))\nmodel1.add(Dropout(rate=0.2))\nmodel1.add(Dense(10))\nmodel1.add(Activation('softmax'))\nmodel1.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='adam')",
"_____no_output_____"
],
[
"model1.summary()",
"Model: \"sequential_3\"\n_________________________________________________________________\nLayer (type) Output Shape Param # \n=================================================================\ndense_3 (Dense) (None, 512) 401920 \n_________________________________________________________________\nactivation_3 (Activation) (None, 512) 0 \n_________________________________________________________________\ndropout_1 (Dropout) (None, 512) 0 \n_________________________________________________________________\ndense_4 (Dense) (None, 10) 5130 \n_________________________________________________________________\nactivation_4 (Activation) (None, 10) 0 \n=================================================================\nTotal params: 407,050\nTrainable params: 407,050\nNon-trainable params: 0\n_________________________________________________________________\n"
],
[
"#model1 = load_model_weights('nn3', model1)",
"_____no_output_____"
],
[
"history1 = model1.fit(X_train, T_train, batch_size=1024, epochs=10, verbose=1, validation_data=(X_test, T_test))",
"Train on 60000 samples, validate on 10000 samples\nEpoch 1/10\n60000/60000 [==============================] - 3s 50us/step - loss: 0.5838 - accuracy: 0.8402 - val_loss: 0.2569 - val_accuracy: 0.9255\nEpoch 2/10\n60000/60000 [==============================] - 3s 47us/step - loss: 0.2396 - accuracy: 0.9313 - val_loss: 0.1899 - val_accuracy: 0.9447\nEpoch 3/10\n60000/60000 [==============================] - 3s 47us/step - loss: 0.1817 - accuracy: 0.9485 - val_loss: 0.1513 - val_accuracy: 0.9558\nEpoch 4/10\n60000/60000 [==============================] - 3s 47us/step - loss: 0.1454 - accuracy: 0.9587 - val_loss: 0.1284 - val_accuracy: 0.9628\nEpoch 5/10\n60000/60000 [==============================] - 3s 47us/step - loss: 0.1229 - accuracy: 0.9653 - val_loss: 0.1127 - val_accuracy: 0.9665\nEpoch 6/10\n60000/60000 [==============================] - 3s 46us/step - loss: 0.1059 - accuracy: 0.9703 - val_loss: 0.1007 - val_accuracy: 0.9710\nEpoch 7/10\n60000/60000 [==============================] - 3s 47us/step - loss: 0.0924 - accuracy: 0.9738 - val_loss: 0.0917 - val_accuracy: 0.9733\nEpoch 8/10\n60000/60000 [==============================] - 3s 47us/step - loss: 0.0808 - accuracy: 0.9773 - val_loss: 0.0862 - val_accuracy: 0.9738\nEpoch 9/10\n60000/60000 [==============================] - 3s 47us/step - loss: 0.0713 - accuracy: 0.9794 - val_loss: 0.0805 - val_accuracy: 0.9763\nEpoch 10/10\n60000/60000 [==============================] - 3s 47us/step - loss: 0.0639 - accuracy: 0.9823 - val_loss: 0.0751 - val_accuracy: 0.9776\n"
],
[
"save_model(model1,'nn3')",
"Saved model to disk\n"
],
[
"history1_df = pd.DataFrame(history1.history)",
"_____no_output_____"
],
[
"history1_df.head()",
"_____no_output_____"
],
[
"plotAccuracy(history1_df.accuracy, history1_df.val_accuracy)",
"_____no_output_____"
],
[
"predictions_train = model1.predict_classes(X_train, verbose=0)",
"_____no_output_____"
],
[
"confusion_matrix(t_train, predictions_train)",
"_____no_output_____"
],
[
"accuracy_score(t_train, predictions_train)",
"_____no_output_____"
],
[
"meas = precision_recall_fscore_support(t_train, predictions_train, average=None)\nprint('Training set')\nfor i in range(10):\n print('Class {0:d}: precision={1:5.2f}, recall={2:5.2f}, f-measure={2:5.2f}'.format(i, meas[1][i], meas[2][i], meas[3][i]))",
"Training set\nClass 0: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 1: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 2: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 3: precision= 0.98, recall= 0.99, f-measure= 0.99\nClass 4: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 5: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 6: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 7: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 8: precision= 0.98, recall= 0.98, f-measure= 0.98\nClass 9: precision= 0.98, recall= 0.98, f-measure= 0.98\n"
],
[
"predictions_test = model1.predict_classes(X_test, verbose=0)",
"_____no_output_____"
],
[
"confusion_matrix(t_test, predictions_test)",
"_____no_output_____"
],
[
"accuracy_score(t_test, predictions_test)",
"_____no_output_____"
],
[
"meas = precision_recall_fscore_support(t_test, predictions_test, average=None)\nprint('Test set')\nfor i in range(10):\n print('Class {0:d}: precision={1:5.2f}, recall={2:5.2f}, f-measure={2:5.2f}'.format(i, meas[1][i], meas[2][i], meas[3][i]))",
"Test set\nClass 0: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 1: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 2: precision= 0.98, recall= 0.97, f-measure= 0.97\nClass 3: precision= 0.98, recall= 0.97, f-measure= 0.97\nClass 4: precision= 0.98, recall= 0.98, f-measure= 0.98\nClass 5: precision= 0.98, recall= 0.98, f-measure= 0.98\nClass 6: precision= 0.97, recall= 0.98, f-measure= 0.98\nClass 7: precision= 0.97, recall= 0.98, f-measure= 0.98\nClass 8: precision= 0.96, recall= 0.97, f-measure= 0.97\nClass 9: precision= 0.96, recall= 0.97, f-measure= 0.97\n"
],
[
"# 4 layer NN\nmodel2 = Sequential()\nmodel2.add(Dense(512, input_shape=(784,)))\nmodel2.add(Activation('relu'))\nmodel2.add(Dropout(0.2))\nmodel2.add(Dense(512))\nmodel2.add(Activation('relu'))\nmodel2.add(Dropout(0.2))\nmodel2.add(Dense(10))\nmodel2.add(Activation('softmax'))",
"_____no_output_____"
],
[
"model2.summary()",
"Model: \"sequential_4\"\n_________________________________________________________________\nLayer (type) Output Shape Param # \n=================================================================\ndense_5 (Dense) (None, 512) 401920 \n_________________________________________________________________\nactivation_5 (Activation) (None, 512) 0 \n_________________________________________________________________\ndropout_2 (Dropout) (None, 512) 0 \n_________________________________________________________________\ndense_6 (Dense) (None, 512) 262656 \n_________________________________________________________________\nactivation_6 (Activation) (None, 512) 0 \n_________________________________________________________________\ndropout_3 (Dropout) (None, 512) 0 \n_________________________________________________________________\ndense_7 (Dense) (None, 10) 5130 \n_________________________________________________________________\nactivation_7 (Activation) (None, 10) 0 \n=================================================================\nTotal params: 669,706\nTrainable params: 669,706\nNon-trainable params: 0\n_________________________________________________________________\n"
],
[
"model2.compile(loss='categorical_crossentropy', metrics=['accuracy'], optimizer='adam')",
"_____no_output_____"
],
[
"#model2 = load_model_weights('nn4', model2)",
"_____no_output_____"
],
[
"history2 = model2.fit(X_train, T_train, batch_size=1024, epochs=10, verbose=1, validation_data=(X_test, T_test))",
"Train on 60000 samples, validate on 10000 samples\nEpoch 1/10\n60000/60000 [==============================] - 5s 88us/step - loss: 0.5063 - accuracy: 0.8563 - val_loss: 0.1870 - val_accuracy: 0.9435\nEpoch 2/10\n60000/60000 [==============================] - 5s 84us/step - loss: 0.1752 - accuracy: 0.9492 - val_loss: 0.1212 - val_accuracy: 0.9627\nEpoch 3/10\n60000/60000 [==============================] - 5s 84us/step - loss: 0.1217 - accuracy: 0.9638 - val_loss: 0.1025 - val_accuracy: 0.9677\nEpoch 4/10\n60000/60000 [==============================] - 5s 85us/step - loss: 0.0933 - accuracy: 0.9722 - val_loss: 0.0808 - val_accuracy: 0.9747\nEpoch 5/10\n60000/60000 [==============================] - 5s 85us/step - loss: 0.0746 - accuracy: 0.9779 - val_loss: 0.0720 - val_accuracy: 0.9770\nEpoch 6/10\n60000/60000 [==============================] - 5s 85us/step - loss: 0.0579 - accuracy: 0.9824 - val_loss: 0.0654 - val_accuracy: 0.9791\nEpoch 7/10\n60000/60000 [==============================] - 5s 86us/step - loss: 0.0502 - accuracy: 0.9840 - val_loss: 0.0623 - val_accuracy: 0.9806\nEpoch 8/10\n60000/60000 [==============================] - 5s 85us/step - loss: 0.0420 - accuracy: 0.9874 - val_loss: 0.0605 - val_accuracy: 0.9803\nEpoch 9/10\n60000/60000 [==============================] - 5s 85us/step - loss: 0.0355 - accuracy: 0.9896 - val_loss: 0.0596 - val_accuracy: 0.9807\nEpoch 10/10\n60000/60000 [==============================] - 5s 85us/step - loss: 0.0305 - accuracy: 0.9907 - val_loss: 0.0577 - val_accuracy: 0.9817\n"
],
[
"save_model(model2,'nn4')",
"Saved model to disk\n"
],
[
"history2_df = pd.DataFrame(history2.history)",
"_____no_output_____"
],
[
"history2_df.head()",
"_____no_output_____"
],
[
"plotAccuracy(history2_df.accuracy, history2_df.val_accuracy)",
"_____no_output_____"
],
[
"predictions_train = model2.predict_classes(X_train, verbose=0)",
"_____no_output_____"
],
[
"confusion_matrix(t_train, predictions_train)",
"_____no_output_____"
],
[
"accuracy_score(t_train, predictions_train)",
"_____no_output_____"
],
[
"meas = precision_recall_fscore_support(t_train, predictions_train, average=None)\nprint('Training set')\nfor i in range(10):\n print('Class {0:d}: precision={1:5.2f}, recall={2:5.2f}, f-measure={2:5.2f}'.format(i, meas[1][i], meas[2][i], meas[3][i]))",
"Training set\nClass 0: precision= 1.00, recall= 1.00, f-measure= 1.00\nClass 1: precision= 1.00, recall= 1.00, f-measure= 1.00\nClass 2: precision= 1.00, recall= 1.00, f-measure= 1.00\nClass 3: precision= 1.00, recall= 1.00, f-measure= 1.00\nClass 4: precision= 1.00, recall= 1.00, f-measure= 1.00\nClass 5: precision= 1.00, recall= 1.00, f-measure= 1.00\nClass 6: precision= 1.00, recall= 1.00, f-measure= 1.00\nClass 7: precision= 1.00, recall= 1.00, f-measure= 1.00\nClass 8: precision= 1.00, recall= 1.00, f-measure= 1.00\nClass 9: precision= 0.99, recall= 1.00, f-measure= 1.00\n"
],
[
"predictions_test = model2.predict_classes(X_test, verbose=0)",
"_____no_output_____"
],
[
"confusion_matrix(t_test, predictions_test)",
"_____no_output_____"
],
[
"accuracy_score(t_test, predictions_test)",
"_____no_output_____"
],
[
"meas = precision_recall_fscore_support(t_test, predictions_test, average=None)\nprint('Test set')\nfor i in range(10):\n print('Class {0:d}: precision={1:5.2f}, recall={2:5.2f}, f-measure={2:5.2f}'.format(i, meas[1][i], meas[2][i], meas[3][i]))",
"Test set\nClass 0: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 1: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 2: precision= 0.98, recall= 0.98, f-measure= 0.98\nClass 3: precision= 0.99, recall= 0.98, f-measure= 0.98\nClass 4: precision= 0.98, recall= 0.98, f-measure= 0.98\nClass 5: precision= 0.98, recall= 0.98, f-measure= 0.98\nClass 6: precision= 0.97, recall= 0.98, f-measure= 0.98\nClass 7: precision= 0.98, recall= 0.98, f-measure= 0.98\nClass 8: precision= 0.98, recall= 0.98, f-measure= 0.98\nClass 9: precision= 0.97, recall= 0.97, f-measure= 0.97\n"
],
[
"model3 = Sequential()\nmodel3.add(Conv2D(30, (5, 5), input_shape=(28, 28,1), activation='relu'))\nmodel3.add(MaxPooling2D(pool_size=(2, 2)))\nmodel3.add(Conv2D(15, (3, 3), activation='relu'))\nmodel3.add(MaxPooling2D(pool_size=(2, 2)))\nmodel3.add(Dropout(0.2))\nmodel3.add(Flatten())\nmodel3.add(Dense(128, activation='relu'))\nmodel3.add(Dense(50, activation='relu'))\nmodel3.add(Dense(10, activation='softmax'))",
"_____no_output_____"
],
[
"model3.summary()",
"Model: \"sequential_7\"\n_________________________________________________________________\nLayer (type) Output Shape Param # \n=================================================================\nconv2d_4 (Conv2D) (None, 24, 24, 30) 780 \n_________________________________________________________________\nmax_pooling2d_3 (MaxPooling2 (None, 12, 12, 30) 0 \n_________________________________________________________________\nconv2d_5 (Conv2D) (None, 10, 10, 15) 4065 \n_________________________________________________________________\nmax_pooling2d_4 (MaxPooling2 (None, 5, 5, 15) 0 \n_________________________________________________________________\ndropout_5 (Dropout) (None, 5, 5, 15) 0 \n_________________________________________________________________\nflatten_2 (Flatten) (None, 375) 0 \n_________________________________________________________________\ndense_11 (Dense) (None, 128) 48128 \n_________________________________________________________________\ndense_12 (Dense) (None, 50) 6450 \n_________________________________________________________________\ndense_13 (Dense) (None, 10) 510 \n=================================================================\nTotal params: 59,933\nTrainable params: 59,933\nNon-trainable params: 0\n_________________________________________________________________\n"
],
[
"model3.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])",
"_____no_output_____"
],
[
"X_train_c = X_train.reshape(X_train.shape[0], 28, 28,1).astype('float32')\nX_test_c = X_test.reshape(X_test.shape[0], 28, 28, 1).astype('float32')",
"_____no_output_____"
],
[
"#model3 = load_model_weights('cnn', model3)",
"_____no_output_____"
],
[
"history3 = model3.fit(X_train_c, T_train, batch_size=1024, epochs=10, verbose=1, validation_data=(X_test_c, T_test))",
"Train on 60000 samples, validate on 10000 samples\nEpoch 1/10\n60000/60000 [==============================] - 33s 556us/step - loss: 1.0933 - accuracy: 0.6511 - val_loss: 0.2442 - val_accuracy: 0.9319\nEpoch 2/10\n60000/60000 [==============================] - 33s 547us/step - loss: 0.2142 - accuracy: 0.9366 - val_loss: 0.1038 - val_accuracy: 0.9687\nEpoch 3/10\n60000/60000 [==============================] - 33s 553us/step - loss: 0.1253 - accuracy: 0.9624 - val_loss: 0.0693 - val_accuracy: 0.9782\nEpoch 4/10\n60000/60000 [==============================] - 33s 545us/step - loss: 0.0976 - accuracy: 0.9699 - val_loss: 0.0532 - val_accuracy: 0.9830\nEpoch 5/10\n60000/60000 [==============================] - 33s 545us/step - loss: 0.0831 - accuracy: 0.9745 - val_loss: 0.0469 - val_accuracy: 0.9857\nEpoch 6/10\n60000/60000 [==============================] - 33s 545us/step - loss: 0.0705 - accuracy: 0.9783 - val_loss: 0.0437 - val_accuracy: 0.9852\nEpoch 7/10\n60000/60000 [==============================] - 33s 543us/step - loss: 0.0617 - accuracy: 0.9808 - val_loss: 0.0384 - val_accuracy: 0.9872\nEpoch 8/10\n60000/60000 [==============================] - 33s 544us/step - loss: 0.0567 - accuracy: 0.9825 - val_loss: 0.0328 - val_accuracy: 0.9887\nEpoch 9/10\n60000/60000 [==============================] - 33s 545us/step - loss: 0.0528 - accuracy: 0.9829 - val_loss: 0.0321 - val_accuracy: 0.9894\nEpoch 10/10\n60000/60000 [==============================] - 33s 545us/step - loss: 0.0464 - accuracy: 0.9852 - val_loss: 0.0299 - val_accuracy: 0.9902\n"
],
[
"save_model(model3,'cnn')",
"Saved model to disk\n"
],
[
"history3_df = pd.DataFrame(history3.history) ",
"_____no_output_____"
],
[
"history3_df.head()",
"_____no_output_____"
],
[
"plotAccuracy(history3_df.accuracy, history3_df.val_accuracy)",
"_____no_output_____"
],
[
"predictions_train = model3.predict_classes(X_train_c, verbose=0)",
"_____no_output_____"
],
[
"confusion_matrix(t_train, predictions_train)",
"_____no_output_____"
],
[
"accuracy_score(t_train, predictions_train)",
"_____no_output_____"
],
[
"meas = precision_recall_fscore_support(t_train, predictions_train, average=None)\nprint('Training set')\nfor i in range(10):\n print('Class {0:d}: precision={1:5.2f}, recall={2:5.2f}, f-measure={2:5.2f}'.format(i, meas[1][i], meas[2][i], meas[3][i]))",
"Training set\nClass 0: precision= 1.00, recall= 1.00, f-measure= 1.00\nClass 1: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 2: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 3: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 4: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 5: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 6: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 7: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 8: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 9: precision= 0.99, recall= 0.99, f-measure= 0.99\n"
],
[
"predictions_test = model3.predict_classes(X_test_c, verbose=0)",
"_____no_output_____"
],
[
"confusion_matrix(t_test, predictions_test)",
"_____no_output_____"
],
[
"accuracy_score(t_test, predictions_test)",
"_____no_output_____"
],
[
"meas = precision_recall_fscore_support(t_test, predictions_test, average=None)\nprint('Test set')\nfor i in range(10):\n print('Class {0:d}: precision={1:5.2f}, recall={2:5.2f}, f-measure={2:5.2f}'.format(i, meas[1][i], meas[2][i], meas[3][i]))",
"Test set\nClass 0: precision= 1.00, recall= 0.99, f-measure= 0.99\nClass 1: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 2: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 3: precision= 1.00, recall= 0.99, f-measure= 0.99\nClass 4: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 5: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 6: precision= 0.98, recall= 0.99, f-measure= 0.99\nClass 7: precision= 0.98, recall= 0.99, f-measure= 0.99\nClass 8: precision= 0.99, recall= 0.99, f-measure= 0.99\nClass 9: precision= 0.98, recall= 0.98, f-measure= 0.98\n"
]
]
] | [
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"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"
]
] |
ecebaf4710e4a9483f67585dd2aaec9a6310cd19 | 1,160 | ipynb | Jupyter Notebook | index.ipynb | RobInLabUJI/ROS-Notebooks | b92c1f0cb88fd52b24d0f5d24d9278894b27d1f3 | [
"MIT"
] | 2 | 2021-05-23T18:03:41.000Z | 2021-12-23T21:44:59.000Z | index.ipynb | RobInLabUJI/ROS-Notebooks | b92c1f0cb88fd52b24d0f5d24d9278894b27d1f3 | [
"MIT"
] | null | null | null | index.ipynb | RobInLabUJI/ROS-Notebooks | b92c1f0cb88fd52b24d0f5d24d9278894b27d1f3 | [
"MIT"
] | null | null | null | 17.058824 | 59 | 0.506034 | [
[
[
"# ROS Notebooks",
"_____no_output_____"
],
[
"## [Core ROS Tutorials](Tutorials/index.ipynb)\n",
"_____no_output_____"
],
[
"## [Stage](Tutorials/Stage/index.ipynb)\n",
"_____no_output_____"
],
[
"## [Gazebo](Gazebo/index.ipynb)\n",
"_____no_output_____"
],
[
"## [Try a TurtleBot](try-a-turtlebot/default.ipynb)\n",
"_____no_output_____"
]
]
] | [
"markdown"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
]
] |
ecebcc77c161d9f8452ca716c148a9b5755c4b3f | 74,387 | ipynb | Jupyter Notebook | notebooks/autoencoder/01_basic_autoencoder.ipynb | tingsyo/course_2020Q3_representation_learning | 642b8ffdfaf6bfb2b2456af31d9dd8cf66716b64 | [
"Apache-2.0"
] | null | null | null | notebooks/autoencoder/01_basic_autoencoder.ipynb | tingsyo/course_2020Q3_representation_learning | 642b8ffdfaf6bfb2b2456af31d9dd8cf66716b64 | [
"Apache-2.0"
] | null | null | null | notebooks/autoencoder/01_basic_autoencoder.ipynb | tingsyo/course_2020Q3_representation_learning | 642b8ffdfaf6bfb2b2456af31d9dd8cf66716b64 | [
"Apache-2.0"
] | null | null | null | 121.151466 | 22,968 | 0.767083 | [
[
[
"import numpy as np\nimport pandas as pd",
"_____no_output_____"
]
],
[
[
"## Model",
"_____no_output_____"
]
],
[
[
"# Let's build the simplest possible autoencoder\nfrom keras.layers import Input, Dense\nfrom keras.models import Model\n\n# this is the size of our encoded representations\nencoding_dim = 32 # 32 floats -> compression of factor 24.5, assuming the input is 784 floats\n\n# this is our input placeholder\ninput_img = Input(shape=(784,))\n# \"encoded\" is the encoded representation of the input\nencoded = Dense(encoding_dim, activation='relu')(input_img)\n# \"decoded\" is the lossy reconstruction of the input\ndecoded = Dense(784, activation='sigmoid')(encoded)\n# this model maps an input to its reconstruction\nautoencoder = Model(input_img, decoded)\n# Configure our model to use a per-pixel binary crossentropy loss, and the Adadelta optimizer:\nautoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')\n\n\n# Create a separate encoder model:\n# this model maps an input to its encoded representation\nencoder = Model(input_img, encoded)\n\n\n# Create a separate decoder model:\n# create a placeholder for an encoded (32-dimensional) input\nencoded_input = Input(shape=(encoding_dim,))\n# retrieve the last layer of the autoencoder model\ndecoder_layer = autoencoder.layers[-1]\n# create the decoder model\ndecoder = Model(encoded_input, decoder_layer(encoded_input))",
"_____no_output_____"
]
],
[
[
"## Data",
"_____no_output_____"
]
],
[
[
"# Data\n# Let's prepare our input data. We're using MNIST digits, and we're discarding the labels \n# (since we're only interested in encoding/decoding the input images).\nfrom keras.datasets import mnist\nimport numpy as np\n(x_train, _), (x_test, _) = mnist.load_data()\n\n# We will normalize all values between 0 and 1 and we will flatten the 28x28 images into vectors of size 784.\nx_train = x_train.astype('float32') / 255.\nx_test = x_test.astype('float32') / 255.\nx_train = x_train.reshape((len(x_train), np.prod(x_train.shape[1:])))\nx_test = x_test.reshape((len(x_test), np.prod(x_test.shape[1:])))\nprint(x_train.shape)\nprint(x_test.shape)",
"(60000, 784)\n(10000, 784)\n"
]
],
[
[
"## Training\n\nNow let's train our autoencoder for 50 epochs:",
"_____no_output_____"
]
],
[
[
"autoencoder.fit(x_train, x_train,\n epochs=50,\n batch_size=256,\n shuffle=True,\n validation_data=(x_test, x_test))",
"Train on 60000 samples, validate on 10000 samples\nEpoch 1/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1042 - val_loss: 0.1023\nEpoch 2/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1039 - val_loss: 0.1020\nEpoch 3/50\n60000/60000 [==============================] - 1s 11us/step - loss: 0.1036 - val_loss: 0.1017\nEpoch 4/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1033 - val_loss: 0.1014\nEpoch 5/50\n60000/60000 [==============================] - 1s 11us/step - loss: 0.1030 - val_loss: 0.1012\nEpoch 6/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1027 - val_loss: 0.1009\nEpoch 7/50\n60000/60000 [==============================] - 1s 11us/step - loss: 0.1025 - val_loss: 0.1007\nEpoch 8/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1022 - val_loss: 0.1004\nEpoch 9/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1020 - val_loss: 0.1002\nEpoch 10/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1018 - val_loss: 0.1000\nEpoch 11/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1015 - val_loss: 0.0998\nEpoch 12/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1013 - val_loss: 0.0996\nEpoch 13/50\n60000/60000 [==============================] - 1s 11us/step - loss: 0.1011 - val_loss: 0.0994\nEpoch 14/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1009 - val_loss: 0.0992\nEpoch 15/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1008 - val_loss: 0.0990\nEpoch 16/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1006 - val_loss: 0.0989\nEpoch 17/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1004 - val_loss: 0.0987\nEpoch 18/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1003 - val_loss: 0.0986\nEpoch 19/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1001 - val_loss: 0.0985\nEpoch 20/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.1000 - val_loss: 0.0983\nEpoch 21/50\n60000/60000 [==============================] - 1s 11us/step - loss: 0.0999 - val_loss: 0.0982\nEpoch 22/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0997 - val_loss: 0.0981\nEpoch 23/50\n60000/60000 [==============================] - 1s 11us/step - loss: 0.0996 - val_loss: 0.0980\nEpoch 24/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0995 - val_loss: 0.0979\nEpoch 25/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0994 - val_loss: 0.0978\nEpoch 26/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0993 - val_loss: 0.0977\nEpoch 27/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0992 - val_loss: 0.0976\nEpoch 28/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0991 - val_loss: 0.0975\nEpoch 29/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0991 - val_loss: 0.0975\nEpoch 30/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0990 - val_loss: 0.0974\nEpoch 31/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0989 - val_loss: 0.0973\nEpoch 32/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0988 - val_loss: 0.0972\nEpoch 33/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0988 - val_loss: 0.0972\nEpoch 34/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0987 - val_loss: 0.0971\nEpoch 35/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0986 - val_loss: 0.0971\nEpoch 36/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0986 - val_loss: 0.0970\nEpoch 37/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0985 - val_loss: 0.0969\nEpoch 38/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0985 - val_loss: 0.0969\nEpoch 39/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0984 - val_loss: 0.0968\nEpoch 40/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0983 - val_loss: 0.0968\nEpoch 41/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0983 - val_loss: 0.0967\nEpoch 42/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0982 - val_loss: 0.0967\nEpoch 43/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0982 - val_loss: 0.0966\nEpoch 44/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0981 - val_loss: 0.0966\nEpoch 45/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0981 - val_loss: 0.0966\nEpoch 46/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0981 - val_loss: 0.0965\nEpoch 47/50\n60000/60000 [==============================] - 1s 13us/step - loss: 0.0980 - val_loss: 0.0965\nEpoch 48/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0980 - val_loss: 0.0964\nEpoch 49/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0979 - val_loss: 0.0964\nEpoch 50/50\n60000/60000 [==============================] - 1s 12us/step - loss: 0.0979 - val_loss: 0.0964\n"
]
],
[
[
"## Visualize what the autoencoder do",
"_____no_output_____"
]
],
[
[
"# encode and decode some digits\n# note that we take them from the *test* set\nencoded_imgs = encoder.predict(x_test)\ndecoded_imgs = decoder.predict(encoded_imgs)",
"_____no_output_____"
],
[
"# use Matplotlib (don't ask)\n%matplotlib inline\nimport matplotlib.pyplot as plt\n\nn = 10 # how many digits we will display\nplt.figure(figsize=(20, 4))\nfor i in range(n):\n # display original\n ax = plt.subplot(2, n, i + 1)\n plt.imshow(x_test[i].reshape(28, 28))\n plt.gray()\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n\n # display reconstruction\n ax = plt.subplot(2, n, i + 1 + n)\n plt.imshow(decoded_imgs[i].reshape(28, 28))\n plt.gray()\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\nplt.show()",
"_____no_output_____"
]
],
[
[
"## Adding a sparsity constraint on the encoded representations\n\nIn the previous example, the representations were only constrained by the size of the hidden layer (32). In such a situation, what typically happens is that the hidden layer is learning an approximation of PCA (principal component analysis). But another way to constrain the representations to be compact is to add a sparsity contraint on the activity of the hidden representations, so fewer units would \"fire\" at a given time. In Keras, this can be done by adding an activity_regularizer to our Dense layer:",
"_____no_output_____"
]
],
[
[
"# New version of model\nfrom keras import regularizers\n\nencoding_dim = 32\n\ninput_img = Input(shape=(784,))\n# add a Dense layer with a L1 activity regularizer\nencoded = Dense(encoding_dim, activation='relu',\n activity_regularizer=regularizers.l1(10e-5))(input_img)\ndecoded = Dense(784, activation='sigmoid')(encoded)\nautoencoder = Model(input_img, decoded)\nautoencoder.compile(optimizer='adadelta', loss='binary_crossentropy')\n\n# Training\n# Let's train this model for 100 epochs (with the added regularization the model is \n# less likely to overfit and can be trained longer). The models ends with a train \n# loss of 0.11 and test loss of 0.10. The difference between the two is mostly due \n# to the regularization term being added to the loss during training (worth about 0.01).\nautoencoder.fit(x_train, x_train,\n epochs=100,\n batch_size=256,\n shuffle=True,\n validation_data=(x_test, x_test))\n\n\n# encode and decode some digits\n# note that we take them from the *test* set\nencoded_imgs = encoder.predict(x_test)\ndecoded_imgs = decoder.predict(encoded_imgs)\n\n\n# Show the results\nn = 10 # how many digits we will display\nplt.figure(figsize=(20, 4))\nfor i in range(n):\n # display original\n ax = plt.subplot(2, n, i + 1)\n plt.imshow(x_test[i].reshape(28, 28))\n plt.gray()\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\n\n # display reconstruction\n ax = plt.subplot(2, n, i + 1 + n)\n plt.imshow(decoded_imgs[i].reshape(28, 28))\n plt.gray()\n ax.get_xaxis().set_visible(False)\n ax.get_yaxis().set_visible(False)\nplt.show()",
"Train on 60000 samples, validate on 10000 samples\nEpoch 1/100\n60000/60000 [==============================] - 1s 16us/step - loss: 0.6732 - val_loss: 0.6485\nEpoch 2/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.6284 - val_loss: 0.6090\nEpoch 3/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.5916 - val_loss: 0.5749\nEpoch 4/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.5598 - val_loss: 0.5454\nEpoch 5/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.5323 - val_loss: 0.5198\nEpoch 6/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.5084 - val_loss: 0.4975\nEpoch 7/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.4875 - val_loss: 0.4780\nEpoch 8/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.4692 - val_loss: 0.4609\nEpoch 9/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.4531 - val_loss: 0.4457\nEpoch 10/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.4389 - val_loss: 0.4324\nEpoch 11/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.4262 - val_loss: 0.4205\nEpoch 12/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.4150 - val_loss: 0.4098\nEpoch 13/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.4049 - val_loss: 0.4003\nEpoch 14/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3959 - val_loss: 0.3918\nEpoch 15/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3877 - val_loss: 0.3840\nEpoch 16/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3804 - val_loss: 0.3771\nEpoch 17/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3737 - val_loss: 0.3707\nEpoch 18/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3676 - val_loss: 0.3649\nEpoch 19/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3621 - val_loss: 0.3596\nEpoch 20/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3570 - val_loss: 0.3548\nEpoch 21/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3524 - val_loss: 0.3503\nEpoch 22/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3481 - val_loss: 0.3463\nEpoch 23/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3442 - val_loss: 0.3425\nEpoch 24/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3406 - val_loss: 0.3390\nEpoch 25/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3372 - val_loss: 0.3357\nEpoch 26/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3341 - val_loss: 0.3327\nEpoch 27/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3312 - val_loss: 0.3299\nEpoch 28/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3285 - val_loss: 0.3273\nEpoch 29/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3259 - val_loss: 0.3249\nEpoch 30/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3236 - val_loss: 0.3226\nEpoch 31/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3213 - val_loss: 0.3204\nEpoch 32/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3193 - val_loss: 0.3184\nEpoch 33/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3173 - val_loss: 0.3165\nEpoch 34/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3155 - val_loss: 0.3147\nEpoch 35/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3138 - val_loss: 0.3131\nEpoch 36/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3121 - val_loss: 0.3115\nEpoch 37/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3106 - val_loss: 0.3100\nEpoch 38/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3091 - val_loss: 0.3085\nEpoch 39/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3077 - val_loss: 0.3072\nEpoch 40/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3064 - val_loss: 0.3059\nEpoch 41/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3052 - val_loss: 0.3047\nEpoch 42/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3040 - val_loss: 0.3035\nEpoch 43/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3029 - val_loss: 0.3024\nEpoch 44/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3018 - val_loss: 0.3014\nEpoch 45/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.3008 - val_loss: 0.3004\nEpoch 46/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2998 - val_loss: 0.2994\nEpoch 47/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2989 - val_loss: 0.2985\nEpoch 48/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2980 - val_loss: 0.2976\nEpoch 49/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2971 - val_loss: 0.2968\nEpoch 50/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2963 - val_loss: 0.2960\nEpoch 51/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2955 - val_loss: 0.2952\nEpoch 52/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2948 - val_loss: 0.2945\nEpoch 53/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2941 - val_loss: 0.2938\nEpoch 54/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2934 - val_loss: 0.2931\nEpoch 55/100\n60000/60000 [==============================] - 1s 13us/step - loss: 0.2927 - val_loss: 0.2925\nEpoch 56/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2921 - val_loss: 0.2918\nEpoch 57/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2915 - val_loss: 0.2912\nEpoch 58/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2909 - val_loss: 0.2906\nEpoch 59/100\n60000/60000 [==============================] - 1s 13us/step - loss: 0.2903 - val_loss: 0.2901\nEpoch 60/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2898 - val_loss: 0.2895\nEpoch 61/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2892 - val_loss: 0.2890\nEpoch 62/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2887 - val_loss: 0.2885\nEpoch 63/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2882 - val_loss: 0.2880\nEpoch 64/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2877 - val_loss: 0.2875\nEpoch 65/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2873 - val_loss: 0.2871\nEpoch 66/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2868 - val_loss: 0.2867\nEpoch 67/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2864 - val_loss: 0.2862\nEpoch 68/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2860 - val_loss: 0.2858\nEpoch 69/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2856 - val_loss: 0.2854\nEpoch 70/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2852 - val_loss: 0.2850\nEpoch 71/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2848 - val_loss: 0.2846\nEpoch 72/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2844 - val_loss: 0.2843\nEpoch 73/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2841 - val_loss: 0.2839\nEpoch 74/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2837 - val_loss: 0.2836\nEpoch 75/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2834 - val_loss: 0.2832\nEpoch 76/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2831 - val_loss: 0.2829\nEpoch 77/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2828 - val_loss: 0.2826\nEpoch 78/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2825 - val_loss: 0.2823\nEpoch 79/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2822 - val_loss: 0.2820\nEpoch 80/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2819 - val_loss: 0.2817\nEpoch 81/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2816 - val_loss: 0.2814\nEpoch 82/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2813 - val_loss: 0.2812\nEpoch 83/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2810 - val_loss: 0.2809\nEpoch 84/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2808 - val_loss: 0.2806\nEpoch 85/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2805 - val_loss: 0.2804\nEpoch 86/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2803 - val_loss: 0.2801\nEpoch 87/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2800 - val_loss: 0.2799\nEpoch 88/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2798 - val_loss: 0.2796\nEpoch 89/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2796 - val_loss: 0.2794\nEpoch 90/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2793 - val_loss: 0.2792\nEpoch 91/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2791 - val_loss: 0.2790\nEpoch 92/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2789 - val_loss: 0.2788\nEpoch 93/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2787 - val_loss: 0.2785\nEpoch 94/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2785 - val_loss: 0.2783\nEpoch 95/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2783 - val_loss: 0.2781\nEpoch 96/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2781 - val_loss: 0.2779\nEpoch 97/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2779 - val_loss: 0.2778\nEpoch 98/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2777 - val_loss: 0.2776\nEpoch 99/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2775 - val_loss: 0.2774\nEpoch 100/100\n60000/60000 [==============================] - 1s 12us/step - loss: 0.2774 - val_loss: 0.2772\n"
]
]
] | [
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
],
[
"markdown"
],
[
"code"
]
] |
ecebe23ed72180374d51374d3613bc4f5ddad496 | 230,156 | ipynb | Jupyter Notebook | seaborn.ipynb | m-rafiul-islam/data-science | 670de5ad6f7136f80e107e5d78c11143ac010e01 | [
"MIT"
] | null | null | null | seaborn.ipynb | m-rafiul-islam/data-science | 670de5ad6f7136f80e107e5d78c11143ac010e01 | [
"MIT"
] | null | null | null | seaborn.ipynb | m-rafiul-islam/data-science | 670de5ad6f7136f80e107e5d78c11143ac010e01 | [
"MIT"
] | null | null | null | 181.225197 | 41,342 | 0.825214 | [
[
[
"<a href=\"https://colab.research.google.com/github/m-rafiul-islam/data-science/blob/main/seaborn.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>",
"_____no_output_____"
]
],
[
[
"import seaborn as sns\ntips = sns.load_dataset(\"tips\")\n%matplotlib inline \ntips.head()",
"_____no_output_____"
],
[
"sns.(x='total_bill',data=tips)",
"_____no_output_____"
],
[
"# tips.head()\nsns.factorplot('day','total_bill', data=tips,kind='violin',hue='sex')",
"/usr/local/lib/python3.7/dist-packages/seaborn/categorical.py:3717: UserWarning: The `factorplot` function has been renamed to `catplot`. The original name will be removed in a future release. Please update your code. Note that the default `kind` in `factorplot` (`'point'`) has changed `'strip'` in `catplot`.\n warnings.warn(msg)\n/usr/local/lib/python3.7/dist-packages/seaborn/_decorators.py:43: FutureWarning: Pass the following variables as keyword args: x, y. From version 0.12, the only valid positional argument will be `data`, and passing other arguments without an explicit keyword will result in an error or misinterpretation.\n FutureWarning\n"
],
[
"flights = sns.load_dataset('flights')\nflights.head()",
"_____no_output_____"
],
[
"tcor = tips.corr()\nsns.heatmap(tcor)\nsns.heatmap(tcor,annot=True,cmap='coolwarm')",
"_____no_output_____"
],
[
"fp = flights.pivot_table(values='passengers',index='month',columns='year')\nsns.heatmap(fp,cmap='magma',linecolor='white',linewidths=2)",
"_____no_output_____"
],
[
"",
"_____no_output_____"
]
],
[
[
"`Grides`\n\n```\n`# This is formatted as code`\n```\n\n",
"_____no_output_____"
]
],
[
[
"iris = sns.load_dataset('iris')\niris.head()",
"_____no_output_____"
],
[
"iris['species'].unique()",
"_____no_output_____"
],
[
"# sns.pairplot(iris)\n# g = sns.PairGrid(iris)\nimport matplotlib.pyplot as plt\ng = sns.FacetGrid(data=tips,col='time',row='smoker')\ng.map(plt.scatter,'total_bill', 'tip')\n",
"_____no_output_____"
],
[
"sns.lmplot(x='total_bill',y='tip',data=tips,hue='sex',markers=['o','v'])",
"_____no_output_____"
],
[
"from plotly import __version__\nprint(__version__)",
"5.5.0\n"
],
[
"import seaborn as sns\n# import cufflinks as cf \n",
"_____no_output_____"
],
[
"titanic = sns.load_dataset('titanic')\ntitanic.head()",
"_____no_output_____"
],
[
"# CODE HERE\n# REPLICATE EXERCISE PLOT IMAGE BELOW\n# BE CAREFUL NOT TO OVERWRITE CELL BELOW\n# THAT WOULD REMOVE THE EXERCISE PLOT IMAGE!\n# sns.boxplot(x='fare',y='age',data=titanic)\n# sns.displot(x='fare',y='age',data=titanic)\nsns.jointplot(x='fare',y='age',data=titanic)\n",
"_____no_output_____"
],
[
"from numpy.lib.function_base import corrcoef\n# CODE HERE\n# REPLICATE EXERCISE PLOT IMAGE BELOW\n# BE CAREFUL NOT TO OVERWRITE CELL BELOW\n# THAT WOULD REMOVE THE EXERCISE PLOT IMAGE!\n# sns.boxplot(x='fare',y='age',data=titanic)\n# sns.displot(x='fare',y='age',data=titanic)\nsns.jointplot(x='fare',y='age',data=titanic,corrcoef = True )\n",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ecec095206c7b50a7594129218e33b2b3332f657 | 522,745 | ipynb | Jupyter Notebook | titanic.ipynb | 7wikd/Titanic | 327ea77ec1b9505000acb34e715b6ad8caaf06d5 | [
"MIT"
] | null | null | null | titanic.ipynb | 7wikd/Titanic | 327ea77ec1b9505000acb34e715b6ad8caaf06d5 | [
"MIT"
] | null | null | null | titanic.ipynb | 7wikd/Titanic | 327ea77ec1b9505000acb34e715b6ad8caaf06d5 | [
"MIT"
] | null | null | null | 44.165681 | 28,740 | 0.504005 | [
[
[
"# data analysis and wrangling\nimport pandas as pd\nimport numpy as np\nimport random as rnd\n\n# visualization\nimport seaborn as sns\nimport matplotlib.pyplot as plt\n%matplotlib inline",
"_____no_output_____"
],
[
"train_df = pd.read_csv('./train.csv')\ntest_df = pd.read_csv('./test.csv')\ncombine = [train_df, test_df]",
"_____no_output_____"
],
[
"print(train_df.columns.values)",
"['PassengerId' 'Survived' 'Pclass' 'Name' 'Sex' 'Age' 'SibSp' 'Parch'\n 'Ticket' 'Fare' 'Cabin' 'Embarked']\n"
],
[
"train_df.head()",
"_____no_output_____"
],
[
"train_df.info()\nprint('*'*40)\ntest_df.info()",
"<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 891 entries, 0 to 890\nData columns (total 12 columns):\n # Column Non-Null Count Dtype \n--- ------ -------------- ----- \n 0 PassengerId 891 non-null int64 \n 1 Survived 891 non-null int64 \n 2 Pclass 891 non-null int64 \n 3 Name 891 non-null object \n 4 Sex 891 non-null object \n 5 Age 714 non-null float64\n 6 SibSp 891 non-null int64 \n 7 Parch 891 non-null int64 \n 8 Ticket 891 non-null object \n 9 Fare 891 non-null float64\n 10 Cabin 204 non-null object \n 11 Embarked 889 non-null object \ndtypes: float64(2), int64(5), object(5)\nmemory usage: 83.7+ KB\n****************************************\n<class 'pandas.core.frame.DataFrame'>\nRangeIndex: 418 entries, 0 to 417\nData columns (total 11 columns):\n # Column Non-Null Count Dtype \n--- ------ -------------- ----- \n 0 PassengerId 418 non-null int64 \n 1 Pclass 418 non-null int64 \n 2 Name 418 non-null object \n 3 Sex 418 non-null object \n 4 Age 332 non-null float64\n 5 SibSp 418 non-null int64 \n 6 Parch 418 non-null int64 \n 7 Ticket 418 non-null object \n 8 Fare 417 non-null float64\n 9 Cabin 91 non-null object \n 10 Embarked 418 non-null object \ndtypes: float64(2), int64(4), object(5)\nmemory usage: 36.0+ KB\n"
],
[
"train_df.describe()",
"_____no_output_____"
],
[
"train_df.describe(include=['O'])",
"_____no_output_____"
],
[
"train_df[['Pclass', 'Survived']].groupby(['Pclass'], as_index=False).mean().sort_values(by='Survived', ascending=False)",
"_____no_output_____"
],
[
"train_df[[\"Sex\", \"Survived\"]].groupby(['Sex'], as_index=False).mean().sort_values(by='Survived', ascending=False)",
"_____no_output_____"
],
[
"train_df[[\"SibSp\", \"Survived\"]].groupby(['SibSp'], as_index=False).mean().sort_values(by='Survived', ascending=False)",
"_____no_output_____"
],
[
"train_df[[\"Parch\", \"Survived\"]].groupby(['Parch'], as_index=False).mean().sort_values(by='Survived', ascending=False)",
"_____no_output_____"
],
[
"graph = sns.FacetGrid(train_df, col='Survived')\ngraph.map(plt.hist, 'Age', bins=20)",
"_____no_output_____"
],
[
"grid = sns.FacetGrid(train_df, col='Survived', row='Pclass', size=2.2, aspect=1.6)\ngrid.map(plt.hist, 'Age', alpha=.5, bins=20)\ngrid.add_legend()",
"/home/satwikd/.local/lib/python3.8/site-packages/seaborn/axisgrid.py:316: UserWarning: The `size` parameter has been renamed to `height`; please update your code.\n warnings.warn(msg, UserWarning)\n"
],
[
"grid = sns.FacetGrid(train_df, row='Embarked', size=2.2, aspect=1.6)\ngrid.map(sns.pointplot, 'Pclass', 'Survived', 'Sex', palette='deep')\ngrid.add_legend()",
"/home/satwikd/.local/lib/python3.8/site-packages/seaborn/axisgrid.py:316: UserWarning: The `size` parameter has been renamed to `height`; please update your code.\n warnings.warn(msg, UserWarning)\n/home/satwikd/.local/lib/python3.8/site-packages/seaborn/axisgrid.py:643: UserWarning: Using the pointplot function without specifying `order` is likely to produce an incorrect plot.\n warnings.warn(warning)\n/home/satwikd/.local/lib/python3.8/site-packages/seaborn/axisgrid.py:648: UserWarning: Using the pointplot function without specifying `hue_order` is likely to produce an incorrect plot.\n warnings.warn(warning)\n"
],
[
"grid = sns.FacetGrid(train_df, row='Embarked', col='Survived', size=2.2, aspect=1.6)\ngrid.map(sns.barplot, 'Sex', 'Fare', alpha=.5, ci=None)\ngrid.add_legend()",
"/home/satwikd/.local/lib/python3.8/site-packages/seaborn/axisgrid.py:316: UserWarning: The `size` parameter has been renamed to `height`; please update your code.\n warnings.warn(msg, UserWarning)\n/home/satwikd/.local/lib/python3.8/site-packages/seaborn/axisgrid.py:643: UserWarning: Using the barplot function without specifying `order` is likely to produce an incorrect plot.\n warnings.warn(warning)\n"
],
[
"print(\"Before\", train_df.shape, test_df.shape, combine[0].shape, combine[1].shape)\n\ntrain_df = train_df.drop(['Ticket', 'Cabin'], axis=1)\ntest_df = test_df.drop(['Ticket', 'Cabin'], axis=1)\ncombine = [train_df, test_df]\n\n\"After\", train_df.shape, test_df.shape, combine[0].shape, combine[1].shape",
"Before (891, 12) (418, 11) (891, 12) (418, 11)\n"
],
[
"for dataset in combine:\n dataset['Title'] = dataset.Name.str.extract(' ([A-Za-z]+)\\.', expand=False)\n\npd.crosstab(train_df['Title'], train_df['Sex'])",
"_____no_output_____"
],
[
"for dataset in combine:\n dataset['Title'] = dataset['Title'].replace(['Lady', 'Countess','Capt', 'Col','Don', 'Dr', 'Major', 'Rev', 'Sir', 'Jonkheer', 'Dona'], 'Rare')\n\n dataset['Title'] = dataset['Title'].replace('Mlle', 'Miss')\n dataset['Title'] = dataset['Title'].replace('Ms', 'Miss')\n dataset['Title'] = dataset['Title'].replace('Mme', 'Mrs')\n \ntrain_df[['Title', 'Survived']].groupby(['Title'], as_index=False).mean()",
"_____no_output_____"
],
[
"title_mapping = {\"Mr\": 1, \"Miss\": 2, \"Mrs\": 3, \"Master\": 4, \"Rare\": 5}\nfor dataset in combine:\n dataset['Title'] = dataset['Title'].map(title_mapping)\n dataset['Title'] = dataset['Title'].fillna(0)",
"_____no_output_____"
],
[
"train_df = train_df.drop(['Name', 'PassengerId'], axis=1)\ntest_df = test_df.drop(['Name', 'PassengerId'], axis=1)\ncombine = [train_df, test_df]\ntrain_df.shape, test_df.shape",
"_____no_output_____"
],
[
"for dataset in combine:\n dataset['Sex'] = dataset['Sex'].map( {'female': 1, 'male': 0} ).astype(int)\n\ntrain_df.head()",
"_____no_output_____"
],
[
"grid = sns.FacetGrid(train_df, row='Pclass', col='Sex', size=2.2, aspect=1.6)\ngrid.map(plt.hist, 'Age', alpha=.5, bins=20)\ngrid.add_legend()",
"/home/satwikd/.local/lib/python3.8/site-packages/seaborn/axisgrid.py:316: UserWarning: The `size` parameter has been renamed to `height`; please update your code.\n warnings.warn(msg, UserWarning)\n"
],
[
"for dataset in combine:\n age_avg = dataset['Age'].mean()\n age_std = dataset['Age'].std()\n age_null_count = dataset['Age'].isnull().sum()\n \n age_null_random_list = np.random.randint(age_avg - age_std, age_avg + age_std, size=age_null_count)\n dataset['Age'][np.isnan(dataset['Age'])] = age_null_random_list\n dataset['Age'] = dataset['Age'].astype(int)\n \ntrain_df['CategoricalAge'] = pd.cut(train_df['Age'], 5)\n\nprint (train_df[['CategoricalAge', 'Survived']].groupby(['CategoricalAge'], as_index=False).mean())",
" CategoricalAge Survived\n0 (-0.08, 16.0] 0.518182\n1 (16.0, 32.0] 0.352550\n2 (32.0, 48.0] 0.380000\n3 (48.0, 64.0] 0.434783\n4 (64.0, 80.0] 0.090909\n<ipython-input-153-d29f5f4de75f>:7: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame\n\nSee the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n dataset['Age'][np.isnan(dataset['Age'])] = age_null_random_list\n"
],
[
"for dataset in combine: \n dataset.loc[ dataset['Age'] <= 16, 'Age'] = 0\n dataset.loc[(dataset['Age'] > 16) & (dataset['Age'] <= 32), 'Age'] = 1\n dataset.loc[(dataset['Age'] > 32) & (dataset['Age'] <= 48), 'Age'] = 2\n dataset.loc[(dataset['Age'] > 48) & (dataset['Age'] <= 64), 'Age'] = 3\n dataset.loc[ dataset['Age'] > 64, 'Age']=4\ntrain_df.head()",
"_____no_output_____"
],
[
"train_df = train_df.drop(['CategoricalAge'], axis=1)\ncombine = [train_df, test_df]\ntrain_df.head()",
"_____no_output_____"
],
[
"for dataset in combine:\n dataset['FamilySize'] = dataset['SibSp'] + dataset['Parch'] + 1\n\ntrain_df[['FamilySize', 'Survived']].groupby(['FamilySize'], as_index=False).mean().sort_values(by='Survived', ascending=False)",
"_____no_output_____"
],
[
"for dataset in combine:\n dataset['IsAlone'] = 0\n dataset.loc[dataset['FamilySize'] == 1, 'IsAlone'] = 1\n\ntrain_df[['IsAlone', 'Survived']].groupby(['IsAlone'], as_index=False).mean()",
"_____no_output_____"
],
[
"train_df = train_df.drop(['Parch', 'SibSp', 'FamilySize'], axis=1)\ntest_df = test_df.drop(['Parch', 'SibSp', 'FamilySize'], axis=1)\ncombine = [train_df, test_df]",
"_____no_output_____"
],
[
"for dataset in combine:\n dataset['Age*Class'] = dataset.Age * dataset.Pclass\n\ntrain_df.loc[:, ['Age*Class', 'Age', 'Pclass']].head(10)",
"_____no_output_____"
],
[
"freq_port = train_df.Embarked.dropna().mode()[0]\nfreq_port",
"_____no_output_____"
],
[
"for dataset in combine:\n dataset['Embarked'] = dataset['Embarked'].fillna(freq_port)\n \ntrain_df[['Embarked', 'Survived']].groupby(['Embarked'], as_index=False).mean().sort_values(by='Survived', ascending=False)",
"_____no_output_____"
],
[
"for dataset in combine:\n dataset['Embarked'] = dataset['Embarked'].map( {'S': 0, 'C': 1, 'Q': 2} ).astype(int)\n\ntrain_df.head()\n",
"_____no_output_____"
],
[
"test_df['Fare'].fillna(test_df['Fare'].dropna().median(), inplace=True)\ntest_df.head()",
"_____no_output_____"
],
[
"train_df['FareBand'] = pd.qcut(train_df['Fare'], 4)\ntrain_df[['FareBand', 'Survived']].groupby(['FareBand'], as_index=False).mean().sort_values(by='FareBand', ascending=True)",
"_____no_output_____"
],
[
"for dataset in combine:\n dataset.loc[ dataset['Fare'] <= 7.91, 'Fare'] = 0\n dataset.loc[(dataset['Fare'] > 7.91) & (dataset['Fare'] <= 14.454), 'Fare'] = 1\n dataset.loc[(dataset['Fare'] > 14.454) & (dataset['Fare'] <= 31), 'Fare'] = 2\n dataset.loc[ dataset['Fare'] > 31, 'Fare'] = 3\n dataset['Fare'] = dataset['Fare'].astype(int)\n\ntrain_df = train_df.drop(['FareBand'], axis=1)\ncombine = [train_df, test_df]\n \ntrain_df.head(10)",
"_____no_output_____"
],
[
"from sklearn.linear_model import LogisticRegression\nfrom sklearn.svm import SVC, LinearSVC\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.neighbors import KNeighborsClassifier\nfrom sklearn.naive_bayes import GaussianNB\nfrom sklearn.linear_model import Perceptron\nfrom sklearn.linear_model import SGDClassifier\nfrom sklearn.tree import DecisionTreeClassifier",
"_____no_output_____"
],
[
"X_train = train_df.drop(\"Survived\", axis=1)\nY_train = train_df[\"Survived\"]\nX_test = test_df\nX_train.shape, Y_train.shape, X_test.shape",
"_____no_output_____"
],
[
"# Logistic Regression\nlogreg = LogisticRegression()\nlogreg.fit(X_train, Y_train)\nY_pred = logreg.predict(X_test)\nacc_log = round(logreg.score(X_train, Y_train) * 100, 2)",
"_____no_output_____"
],
[
"coeff_df = pd.DataFrame(train_df.columns.delete(0))\ncoeff_df.columns = ['Feature']\ncoeff_df[\"Correlation\"] = pd.Series(logreg.coef_[0])\n\ncoeff_df.sort_values(by='Correlation', ascending=False)",
"_____no_output_____"
],
[
"# Support Vector Machines\n\nsvc = SVC()\nsvc.fit(X_train, Y_train)\nY_pred = svc.predict(X_test)\nacc_svc = round(svc.score(X_train, Y_train) * 100, 2)",
"_____no_output_____"
],
[
"#KNN\nknn = KNeighborsClassifier(n_neighbors = 3)\nknn.fit(X_train, Y_train)\nY_pred = knn.predict(X_test)\nacc_knn = round(knn.score(X_train, Y_train) * 100, 2)",
"_____no_output_____"
],
[
"# Gaussian Naive Bayes\n\ngaussian = GaussianNB()\ngaussian.fit(X_train, Y_train)\nY_pred = gaussian.predict(X_test)\nacc_gaussian = round(gaussian.score(X_train, Y_train) * 100, 2)",
"_____no_output_____"
],
[
"# Perceptron\n\nperceptron = Perceptron()\nperceptron.fit(X_train, Y_train)\nY_pred = perceptron.predict(X_test)\nacc_perceptron = round(perceptron.score(X_train, Y_train) * 100, 2)",
"_____no_output_____"
],
[
"# Linear SVC\n\nlinear_svc = LinearSVC()\nlinear_svc.fit(X_train, Y_train)\nY_pred = linear_svc.predict(X_test)\nacc_linear_svc = round(linear_svc.score(X_train, Y_train) * 100, 2)",
"/home/satwikd/.local/lib/python3.8/site-packages/sklearn/svm/_base.py:985: ConvergenceWarning: Liblinear failed to converge, increase the number of iterations.\n warnings.warn(\"Liblinear failed to converge, increase \"\n"
],
[
"# Stochastic Gradient Descent\n\nsgd = SGDClassifier()\nsgd.fit(X_train, Y_train)\nY_pred = sgd.predict(X_test)\nacc_sgd = round(sgd.score(X_train, Y_train) * 100, 2)",
"_____no_output_____"
],
[
"# Decision Tree\n\ndecision_tree = DecisionTreeClassifier()\ndecision_tree.fit(X_train, Y_train)\nY_pred = decision_tree.predict(X_test)\nacc_decision_tree = round(decision_tree.score(X_train, Y_train) * 100, 2)",
"_____no_output_____"
],
[
"# Random Forest\n\nrandom_forest = RandomForestClassifier(n_estimators=100)\nrandom_forest.fit(X_train, Y_train)\nY_pred = random_forest.predict(X_test)\nrandom_forest.score(X_train, Y_train)\nacc_random_forest = round(random_forest.score(X_train, Y_train) * 100, 2)",
"_____no_output_____"
],
[
"models = pd.DataFrame({\n 'Model': ['Support Vector Machines', 'KNN', 'Logistic Regression', \n 'Random Forest', 'Naive Bayes', 'Perceptron', \n 'Stochastic Gradient Decent', 'Linear SVC', \n 'Decision Tree'],\n 'Accuracy': [acc_svc, acc_knn, acc_log, \n acc_random_forest, acc_gaussian, acc_perceptron, \n acc_sgd, acc_linear_svc, acc_decision_tree]})\nmodels.sort_values(by='Accuracy', ascending=False)",
"_____no_output_____"
]
]
] | [
"code"
] | [
[
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code",
"code"
]
] |
ecec0eb019e91e39570089d443133398738657c7 | 52,214 | ipynb | Jupyter Notebook | anticipy_hello.ipynb | edwinnglabs/timeseries-notebooks | 9df64fb3a7b70cbfc572e7a926c0ec03bf6351f0 | [
"MIT"
] | null | null | null | anticipy_hello.ipynb | edwinnglabs/timeseries-notebooks | 9df64fb3a7b70cbfc572e7a926c0ec03bf6351f0 | [
"MIT"
] | null | null | null | anticipy_hello.ipynb | edwinnglabs/timeseries-notebooks | 9df64fb3a7b70cbfc572e7a926c0ec03bf6351f0 | [
"MIT"
] | null | null | null | 143.445055 | 33,920 | 0.840081 | [
[
[
"!pip install -U anticipy\nimport logging, sys\nlogging.disable(sys.maxsize)",
"Collecting anticipy\n Downloading anticipy-0.2.1-py3-none-any.whl (74 kB)\n\u001b[?25l\r\u001b[K |████▍ | 10 kB 20.1 MB/s eta 0:00:01\r\u001b[K |████████▉ | 20 kB 3.5 MB/s eta 0:00:01\r\u001b[K |█████████████▏ | 30 kB 4.9 MB/s eta 0:00:01\r\u001b[K |█████████████████▋ | 40 kB 6.2 MB/s eta 0:00:01\r\u001b[K |██████████████████████ | 51 kB 7.3 MB/s eta 0:00:01\r\u001b[K |██████████████████████████▍ | 61 kB 8.4 MB/s eta 0:00:01\r\u001b[K |██████████████████████████████▊ | 71 kB 9.5 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 74 kB 1.6 MB/s \n\u001b[?25hRequirement already satisfied: pandas>=0.23.0 in /usr/local/lib/python3.7/dist-packages (from anticipy) (1.1.5)\nRequirement already satisfied: plotly>=3.5.0 in /usr/local/lib/python3.7/dist-packages (from anticipy) (4.4.1)\nRequirement already satisfied: numpy>=1.15.1 in /usr/local/lib/python3.7/dist-packages (from anticipy) (1.19.5)\nRequirement already satisfied: scipy>=1.0.0 in /usr/local/lib/python3.7/dist-packages (from anticipy) (1.4.1)\nRequirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.23.0->anticipy) (2.8.2)\nRequirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.7/dist-packages (from pandas>=0.23.0->anticipy) (2018.9)\nRequirement already satisfied: six in /usr/local/lib/python3.7/dist-packages (from plotly>=3.5.0->anticipy) (1.15.0)\nRequirement already satisfied: retrying>=1.3.3 in /usr/local/lib/python3.7/dist-packages (from plotly>=3.5.0->anticipy) (1.3.3)\nInstalling collected packages: anticipy\nSuccessfully installed anticipy-0.2.1\n"
],
[
"!pip install microprediction",
"Collecting microprediction\n Downloading microprediction-0.18.8-py3-none-any.whl (73 kB)\n\u001b[?25l\r\u001b[K |████▍ | 10 kB 20.4 MB/s eta 0:00:01\r\u001b[K |████████▉ | 20 kB 25.5 MB/s eta 0:00:01\r\u001b[K |█████████████▎ | 30 kB 31.6 MB/s eta 0:00:01\r\u001b[K |█████████████████▊ | 40 kB 31.4 MB/s eta 0:00:01\r\u001b[K |██████████████████████▏ | 51 kB 20.5 MB/s eta 0:00:01\r\u001b[K |██████████████████████████▋ | 61 kB 22.8 MB/s eta 0:00:01\r\u001b[K |███████████████████████████████ | 71 kB 19.9 MB/s eta 0:00:01\r\u001b[K |████████████████████████████████| 73 kB 2.2 MB/s \n\u001b[?25hRequirement already satisfied: scikit-learn in /usr/local/lib/python3.7/dist-packages (from microprediction) (1.0.1)\nRequirement already satisfied: requests in /usr/local/lib/python3.7/dist-packages (from microprediction) (2.23.0)\nCollecting microconventions>=0.5.0\n Downloading microconventions-0.5.4-py3-none-any.whl (16 kB)\nCollecting pytz>=2021.3\n Downloading pytz-2021.3-py2.py3-none-any.whl (503 kB)\n\u001b[K |████████████████████████████████| 503 kB 46.9 MB/s \n\u001b[?25hCollecting contexttimer\n Downloading contexttimer-0.3.3.tar.gz (4.9 kB)\nRequirement already satisfied: pathlib in /usr/local/lib/python3.7/dist-packages (from microprediction) (1.0.1)\nCollecting tdigest\n Downloading tdigest-0.5.2.2-py3-none-any.whl (9.4 kB)\nRequirement already satisfied: statsmodels in /usr/local/lib/python3.7/dist-packages (from microprediction) (0.10.2)\nCollecting copulas\n Downloading copulas-0.6.0-py2.py3-none-any.whl (50 kB)\n\u001b[K |████████████████████████████████| 50 kB 5.3 MB/s \n\u001b[?25hRequirement already satisfied: pandas in /usr/local/lib/python3.7/dist-packages (from microprediction) (1.1.5)\nCollecting apscheduler\n Downloading APScheduler-3.8.1-py2.py3-none-any.whl (59 kB)\n\u001b[K |████████████████████████████████| 59 kB 5.5 MB/s \n\u001b[?25hRequirement already satisfied: hyperopt in /usr/local/lib/python3.7/dist-packages (from microprediction) (0.1.2)\nCollecting pycoingecko\n Downloading pycoingecko-2.2.0-py3-none-any.whl (8.3 kB)\nCollecting getjson\n Downloading getjson-1.0.0-py3-none-any.whl (2.6 kB)\nCollecting genson\n Downloading genson-1.2.2.tar.gz (34 kB)\nCollecting numpy>=1.20.1\n Downloading numpy-1.21.5-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (15.7 MB)\n\u001b[K |████████████████████████████████| 15.7 MB 46.9 MB/s \n\u001b[?25hRequirement already satisfied: scipy in /usr/local/lib/python3.7/dist-packages (from microconventions>=0.5.0->microprediction) (1.4.1)\nCollecting muid>=0.5.3\n Downloading muid-0.5.3-py3-none-any.whl (173 kB)\n\u001b[K |████████████████████████████████| 173 kB 57.1 MB/s \n\u001b[?25hCollecting pymorton\n Downloading pymorton-1.0.5-py2.py3-none-any.whl (4.4 kB)\nCollecting schema\n Downloading schema-0.7.5-py2.py3-none-any.whl (17 kB)\nCollecting deepdiff\n Downloading deepdiff-5.7.0-py3-none-any.whl (68 kB)\n\u001b[K |████████████████████████████████| 68 kB 6.8 MB/s \n\u001b[?25hCollecting tzlocal!=3.*,>=2.0\n Downloading tzlocal-4.1-py3-none-any.whl (19 kB)\nRequirement already satisfied: setuptools>=0.7 in /usr/local/lib/python3.7/dist-packages (from apscheduler->microprediction) (57.4.0)\nRequirement already satisfied: six>=1.4.0 in /usr/local/lib/python3.7/dist-packages (from apscheduler->microprediction) (1.15.0)\nCollecting backports.zoneinfo\n Downloading backports.zoneinfo-0.2.1-cp37-cp37m-manylinux1_x86_64.whl (70 kB)\n\u001b[K |████████████████████████████████| 70 kB 8.8 MB/s \n\u001b[?25hCollecting pytz-deprecation-shim\n Downloading pytz_deprecation_shim-0.1.0.post0-py2.py3-none-any.whl (15 kB)\nCollecting scipy\n Downloading scipy-1.7.3-cp37-cp37m-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (38.1 MB)\n\u001b[K |████████████████████████████████| 38.1 MB 1.3 MB/s \n\u001b[?25hRequirement already satisfied: matplotlib<4,>=3.2.0 in /usr/local/lib/python3.7/dist-packages (from copulas->microprediction) (3.2.2)\nRequirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4,>=3.2.0->copulas->microprediction) (2.8.2)\nRequirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4,>=3.2.0->copulas->microprediction) (1.3.2)\nRequirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4,>=3.2.0->copulas->microprediction) (0.11.0)\nRequirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.7/dist-packages (from matplotlib<4,>=3.2.0->copulas->microprediction) (3.0.6)\nCollecting ordered-set==4.0.2\n Downloading ordered-set-4.0.2.tar.gz (10 kB)\nCollecting backoff\n Downloading backoff-1.11.1-py2.py3-none-any.whl (13 kB)\nRequirement already satisfied: pymongo in /usr/local/lib/python3.7/dist-packages (from hyperopt->microprediction) (3.12.1)\nRequirement already satisfied: networkx in /usr/local/lib/python3.7/dist-packages (from hyperopt->microprediction) (2.6.3)\nRequirement already satisfied: tqdm in /usr/local/lib/python3.7/dist-packages (from hyperopt->microprediction) (4.62.3)\nRequirement already satisfied: future in /usr/local/lib/python3.7/dist-packages (from hyperopt->microprediction) (0.16.0)\nCollecting tzdata\n Downloading tzdata-2021.5-py2.py3-none-any.whl (339 kB)\n\u001b[K |████████████████████████████████| 339 kB 49.2 MB/s \n\u001b[?25hRequirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.7/dist-packages (from requests->microprediction) (1.24.3)\nRequirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.7/dist-packages (from requests->microprediction) (2.10)\nRequirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.7/dist-packages (from requests->microprediction) (2021.10.8)\nRequirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.7/dist-packages (from requests->microprediction) (3.0.4)\nRequirement already satisfied: contextlib2>=0.5.5 in /usr/local/lib/python3.7/dist-packages (from schema->microconventions>=0.5.0->microprediction) (0.5.5)\nRequirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->microprediction) (3.0.0)\nRequirement already satisfied: joblib>=0.11 in /usr/local/lib/python3.7/dist-packages (from scikit-learn->microprediction) (1.1.0)\nRequirement already satisfied: patsy>=0.4.0 in /usr/local/lib/python3.7/dist-packages (from statsmodels->microprediction) (0.5.2)\nCollecting accumulation-tree\n Downloading accumulation_tree-0.6.2.tar.gz (12 kB)\nCollecting pyudorandom\n Downloading pyudorandom-1.0.0.tar.gz (1.6 kB)\nBuilding wheels for collected packages: contexttimer, ordered-set, genson, accumulation-tree, pyudorandom\n Building wheel for contexttimer (setup.py) ... \u001b[?25l\u001b[?25hdone\n Created wheel for contexttimer: filename=contexttimer-0.3.3-py3-none-any.whl size=5818 sha256=e79ad9c1024c3b80c422e692ed6e73dc356901c82d6a26aa197af71d44f28010\n Stored in directory: /root/.cache/pip/wheels/03/8c/3b/8eba5888c3218e78f7fc4442198abb6db2bd1125c1bfcff183\n Building wheel for ordered-set (setup.py) ... \u001b[?25l\u001b[?25hdone\n Created wheel for ordered-set: filename=ordered_set-4.0.2-py2.py3-none-any.whl size=8219 sha256=df9f7efdadeb4657bc41fdc28b5df159c16ea42a3c3b7c10d10efde91a38221c\n Stored in directory: /root/.cache/pip/wheels/73/2b/f6/26e9f84153c25050fe7c09e88f8e32a6be3c7034a38c418319\n Building wheel for genson (setup.py) ... \u001b[?25l\u001b[?25hdone\n Created wheel for genson: filename=genson-1.2.2-py2.py3-none-any.whl size=21291 sha256=b4e95bfdc76bba35b331d34c7442deacb3391bbab3c8376cb0b6a117fbc52b65\n Stored in directory: /root/.cache/pip/wheels/2e/34/be/0194d05d18bc4695b5c4969178790d535bdd23eabdb9d3b1e3\n Building wheel for accumulation-tree (setup.py) ... \u001b[?25l\u001b[?25hdone\n Created wheel for accumulation-tree: filename=accumulation_tree-0.6.2-cp37-cp37m-linux_x86_64.whl size=234425 sha256=6c109737dd76c58ef0075f13e90112c0f872410d96648f892f21e4eec750157e\n Stored in directory: /root/.cache/pip/wheels/42/32/0e/08020ae396bf92a3fd00971d0b81a6fb8f3e0681fd8912760d\n Building wheel for pyudorandom (setup.py) ... \u001b[?25l\u001b[?25hdone\n Created wheel for pyudorandom: filename=pyudorandom-1.0.0-py3-none-any.whl size=2221 sha256=6f74e6d8fda0e21b3f97deff9ad73068f7b640d2f8f03449d05a6b2df12b7a86\n Stored in directory: /root/.cache/pip/wheels/9b/d0/30/b2916c3efec5b42e574e99d479c032cfa4f13bd0713de1d194\nSuccessfully built contexttimer ordered-set genson accumulation-tree pyudorandom\nInstalling collected packages: tzdata, backports.zoneinfo, pyudorandom, pytz-deprecation-shim, pytz, ordered-set, numpy, contexttimer, backoff, accumulation-tree, tzlocal, tdigest, scipy, schema, pymorton, muid, getjson, deepdiff, pycoingecko, microconventions, genson, copulas, apscheduler, microprediction\n Attempting uninstall: pytz\n Found existing installation: pytz 2018.9\n Uninstalling pytz-2018.9:\n Successfully uninstalled pytz-2018.9\n Attempting uninstall: numpy\n Found existing installation: numpy 1.19.5\n Uninstalling numpy-1.19.5:\n Successfully uninstalled numpy-1.19.5\n Attempting uninstall: tzlocal\n Found existing installation: tzlocal 1.5.1\n Uninstalling tzlocal-1.5.1:\n Successfully uninstalled tzlocal-1.5.1\n Attempting uninstall: scipy\n Found existing installation: scipy 1.4.1\n Uninstalling scipy-1.4.1:\n Successfully uninstalled scipy-1.4.1\n\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\nyellowbrick 1.3.post1 requires numpy<1.20,>=1.16.0, but you have numpy 1.21.5 which is incompatible.\ndatascience 0.10.6 requires folium==0.2.1, but you have folium 0.8.3 which is incompatible.\nalbumentations 0.1.12 requires imgaug<0.2.7,>=0.2.5, but you have imgaug 0.2.9 which is incompatible.\u001b[0m\nSuccessfully installed accumulation-tree-0.6.2 apscheduler-3.8.1 backoff-1.11.1 backports.zoneinfo-0.2.1 contexttimer-0.3.3 copulas-0.6.0 deepdiff-5.7.0 genson-1.2.2 getjson-1.0.0 microconventions-0.5.4 microprediction-0.18.8 muid-0.5.3 numpy-1.21.5 ordered-set-4.0.2 pycoingecko-2.2.0 pymorton-1.0.5 pytz-2021.3 pytz-deprecation-shim-0.1.0.post0 pyudorandom-1.0.0 schema-0.7.5 scipy-1.7.3 tdigest-0.5.2.2 tzdata-2021.5 tzlocal-4.1\n"
]
],
[
[
"### anticipy hello world\nSee https://www.microprediction.com/blog/popular-timeseries-packages for more packages",
"_____no_output_____"
]
],
[
[
"from microprediction import MicroReader\nmr = MicroReader()\nYS = mr.get_lagged_values(name='btc_raw.json')[:400]",
"_____no_output_____"
],
[
"import pandas as pd \nimport datetime \nimport numpy as np\nfrom anticipy import forecast\n\n\ndef anticipy_next(ys:[float])->float:\n \"\"\" Predict the next point in a series \"\"\"\n\n df = pd.DataFrame({'y': ys,\n 'date':pd.date_range(start='2021-01-01', periods=len(ys), freq='D')})\n df_forecast = forecast.run_forecast(df, extrapolate_years=1)\n return (df_forecast.q80.tail(1) + df_forecast.q20.tail(1)) / 2\n \ndef run(ys):\n \"\"\" Slow, see river package or others if you don't like \"\"\"\n burnin = 10\n y_hats = list()\n for t in range(len(ys)):\n if t>burnin:\n y_hat = anticipy_next(ys[:t])\n elif t>=1:\n y_hat = ys[t-1]\n else:\n y_hat = 0 \n y_hats.append(y_hat)\n return y_hats ",
"_____no_output_____"
],
[
"XS = run(YS)",
"_____no_output_____"
],
[
"import matplotlib.pyplot as plt\nplt.plot(YS[200:400],'*b')\nplt.plot(XS[200:400],'g')",
"_____no_output_____"
]
]
] | [
"code",
"markdown",
"code"
] | [
[
"code",
"code"
],
[
"markdown"
],
[
"code",
"code",
"code",
"code"
]
] |
ecec1aa75ea3cb64f6396ff6542b9ecad697bb70 | 3,680 | ipynb | Jupyter Notebook | Jahr 1/M/Gleichungen/Linearegleichungssystem.ipynb | BackInBash/Technikerschule | 6e30654417732fae065e36a40789866ccca6aa7e | [
"MIT"
] | 2 | 2021-01-20T16:16:41.000Z | 2022-01-12T15:37:53.000Z | Jahr 1/M/Gleichungen/Linearegleichungssystem.ipynb | BackInBash/Technikerschule | 6e30654417732fae065e36a40789866ccca6aa7e | [
"MIT"
] | 2 | 2020-06-17T21:55:24.000Z | 2021-09-08T20:40:41.000Z | Jahr 1/M/Gleichungen/Linearegleichungssystem.ipynb | BackInBash/Technikerschule | 6e30654417732fae065e36a40789866ccca6aa7e | [
"MIT"
] | 1 | 2020-12-28T13:03:34.000Z | 2020-12-28T13:03:34.000Z | 20.674157 | 108 | 0.447011 | [
[
[
"# Linearegleichungssystem (LGS)\n\nI\n\\begin{equation*}\n5x+7y=6\n\\end{equation*}\n\nII\n\\begin{equation*}\n4x+y=-1\n\\end{equation*}\n\n## Struktur\nI\n\\begin{equation*}\na*x+b*y=c\n\\end{equation*}\n\nII\n\\begin{equation*}\nd*x+e*y=f\n\\end{equation*}\n\nX = Variable\nd, e, f = Koeffizient (Zahlen die vor der Varaiblen stehen)\n\n## Lösungsverfahren\n\n### Einsetzungsverfahren (EV)\n\nBsp:\nI\n\\begin{equation*}\n8x+2y=6\n\\end{equation*}\nII\n\\begin{equation*}\n4x+y=-1\n\\end{equation*}\nNach Y umformen\n\n\\begin{equation*}\ny=-1-4x\n\\end{equation*}\n\nI\n\\begin{equation*}\n8x+2(-1-4x)=6\n\\end{equation*}\n\nI\n\\begin{equation*}\n8x-2-8=6\n\\end{equation*}\n\nErgebnis:\n\\begin{equation*}\n-2=6\n\\end{equation*}\n\n### Gleichungsverfahren (GV)\n\nI\n\\begin{equation*}\n6x+3y=15\n\\end{equation*}\nII\n\\begin{equation*}\n8x-2y=14\n\\end{equation*}\n\nI\n\\begin{equation*}\ny=\\frac{15-6x}{3} = 5-2x\n\\end{equation*}\nII\n\\begin{equation*}\ny=\\frac{14-8x}{-2}=-7+4x\n\\end{equation*}\n\nI=II\n\\begin{equation*}\n5-2x=-7+4x\n\\end{equation*}\n\\begin{equation*}\n12-2x=4x\n\\end{equation*}\n\\begin{equation*}\n12=6x\n\\end{equation*}\n\\begin{equation*}\nx=2\n\\end{equation*}\n\nX in II\n\\begin{equation*}\n4=-7+4*2=-7+8=1\n\\end{equation*}\n\nL = {(2;1)}\n\n### Additionsverfahren (AV)\nZiel des Additionsverfahrens ist, den Koeffizienten einer Variablen zur Gegenzahl werden zu lassen,\nsodass bei einer Addition beider Gleichungen eine Gleichung mit nur einer Variablen übrig bleibt.\n\nI\n\\begin{equation*}\n3x+2y=12\n\\end{equation*}\n\nII\n\\begin{equation*}\n2x+3y=13\n\\end{equation*}\n\nI*2\n\\begin{equation*}\n6x+4y=24\n\\end{equation*}\n\nII*(-3)\n\\begin{equation*}\n-6x-9y=-39\n\\end{equation*}\n\nI+II\n\\begin{equation*}\n0x-5y=-15\n\\end{equation*}\n\n\\begin{equation*}\ny=3\n\\end{equation*}\n\nY in I\n\\begin{equation*}\n3x+2*3=12\n\\end{equation*}\n\n\\begin{equation*}\nx=2\n\\end{equation*}\n\nL = {(2;3)}",
"_____no_output_____"
]
]
] | [
"markdown"
] | [
[
"markdown"
]
] |
ecec1daea84d611c8afae05a94019f49eafdb5e1 | 138,060 | ipynb | Jupyter Notebook | projects/Recurrent-Neural-Network/rnn-234450/RNN_project.ipynb | DMeechan/AI-Nanodegree | 455f09b14965aed9d0a73fa507fdf35289834dd6 | [
"MIT"
] | 16 | 2017-12-28T05:53:33.000Z | 2019-10-15T23:29:51.000Z | projects/Recurrent-Neural-Network/rnn-234450/RNN_project.ipynb | DMeechan/AI-Nanodegree | 455f09b14965aed9d0a73fa507fdf35289834dd6 | [
"MIT"
] | null | null | null | projects/Recurrent-Neural-Network/rnn-234450/RNN_project.ipynb | DMeechan/AI-Nanodegree | 455f09b14965aed9d0a73fa507fdf35289834dd6 | [
"MIT"
] | 2 | 2019-07-13T06:25:09.000Z | 2021-02-03T01:03:46.000Z | 76.108049 | 39,422 | 0.775301 | [
[
[
"# Artificial Intelligence Nanodegree\n## Recurrent Neural Network Projects\n\nWelcome to the Recurrent Neural Network Project in the Artificial Intelligence Nanodegree! In this notebook, some template code has already been provided for you, and you will need to implement additional functionality to successfully complete this project. You will not need to modify the included code beyond what is requested. Sections that begin with **'Implementation'** in the header indicate that the following block of code will require additional functionality which you must provide. Instructions will be provided for each section and the specifics of the implementation are marked in the code block with a 'TODO' statement. Please be sure to read the instructions carefully!\n\n>**Note:** Code and Markdown cells can be executed using the **Shift + Enter** keyboard shortcut. In addition, Markdown cells can be edited by typically double-clicking the cell to enter edit mode.",
"_____no_output_____"
],
[
"### Implementation TODOs in this notebook\n\nThis notebook contains two problems, cut into a variety of TODOs. Make sure to complete each section containing a TODO marker throughout the notebook. For convenience we provide links to each of these sections below.\n\n[TODO #1: Implement a function to window time series](#TODO_1)\n\n[TODO #2: Create a simple RNN model using keras to perform regression](#TODO_2)\n\n[TODO #3: Finish cleaning a large text corpus](#TODO_3)\n\n[TODO #4: Implement a function to window a large text corpus](#TODO_4)\n\n[TODO #5: Create a simple RNN model using keras to perform multiclass classification](#TODO_5)\n\n[TODO #6: Generate text using a fully trained RNN model and a variety of input sequences](#TODO_6)\n",
"_____no_output_____"
],
[
"# Problem 1: Perform time series prediction \n\nIn this project you will perform time series prediction using a Recurrent Neural Network regressor. In particular you will re-create the figure shown in the notes - where the stock price of Apple was forecasted (or predicted) 7 days in advance. In completing this exercise you will learn how to construct RNNs using Keras, which will also aid in completing the second project in this notebook.\n\nThe particular network architecture we will employ for our RNN is known as [Long Term Short Memory (LSTM)](https://en.wikipedia.org/wiki/Long_short-term_memory), which helps significantly avoid technical problems with optimization of RNNs. ",
"_____no_output_____"
],
[
"## 1.1 Getting started\n\nFirst we must load in our time series - a history of around 140 days of Apple's stock price. Then we need to perform a number of pre-processing steps to prepare it for use with an RNN model. First off, it is good practice to normalize time series - by normalizing its range. This helps us avoid serious numerical issues associated how common activation functions (like tanh) transform very large (positive or negative) numbers, as well as helping us to avoid related issues when computing derivatives.\n\nHere we normalize the series to lie in the range [0,1] [using this scikit function](http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html), but it is also commonplace to normalize by a series standard deviation.",
"_____no_output_____"
]
],
[
[
"### Load in necessary libraries for data input and normalization\n%matplotlib inline\nimport numpy as np\nimport matplotlib.pyplot as plt\n\n%load_ext autoreload\n%autoreload 2\n\nfrom my_answers import *\n\n%load_ext autoreload\n%autoreload 2\n\nfrom my_answers import *\n\n### load in and normalize the dataset\ndataset = np.loadtxt('datasets/normalized_apple_prices.csv')",
"Using TensorFlow backend.\n"
]
],
[
[
"Lets take a quick look at the (normalized) time series we'll be performing predictions on.",
"_____no_output_____"
]
],
[
[
"# lets take a look at our time series\nplt.plot(dataset)\nplt.xlabel('time period')\nplt.ylabel('normalized series value')",
"_____no_output_____"
]
],
[
[
"## 1.2 Cutting our time series into sequences\n\nRemember, our time series is a sequence of numbers that we can represent in general mathematically as \n\n$$s_{0},s_{1},s_{2},...,s_{P}$$\n\nwhere $s_{p}$ is the numerical value of the time series at time period $p$ and where $P$ is the total length of the series. In order to apply our RNN we treat the time series prediction problem as a regression problem, and so need to use a sliding window to construct a set of associated input/output pairs to regress on. This process is animated in the gif below.\n\n<img src=\"images/timeseries_windowing_training.gif\" width=600 height=600/>\n\nFor example - using a window of size T = 5 (as illustrated in the gif above) we produce a set of input/output pairs like the one shown in the table below\n\n$$\\begin{array}{c|c}\n\\text{Input} & \\text{Output}\\\\\n\\hline \\color{CornflowerBlue} {\\langle s_{1},s_{2},s_{3},s_{4},s_{5}\\rangle} & \\color{Goldenrod}{ s_{6}} \\\\\n\\ \\color{CornflowerBlue} {\\langle s_{2},s_{3},s_{4},s_{5},s_{6} \\rangle } & \\color{Goldenrod} {s_{7} } \\\\\n\\color{CornflowerBlue} {\\vdots} & \\color{Goldenrod} {\\vdots}\\\\\n\\color{CornflowerBlue} { \\langle s_{P-5},s_{P-4},s_{P-3},s_{P-2},s_{P-1} \\rangle } & \\color{Goldenrod} {s_{P}}\n\\end{array}$$\n\nNotice here that each input is a sequence (or vector) of length 5 (and in general has length equal to the window size T) while each corresponding output is a scalar value. Notice also how given a time series of length P and window size T = 5 as shown above, we created P - 5 input/output pairs. More generally, for a window size T we create P - T such pairs.",
"_____no_output_____"
],
[
"Now its time for you to window the input time series as described above! \n\n<a id='TODO_1'></a>\n\n**TODO:** Implement the function called **window_transform_series** in my_answers.py so that it runs a sliding window along the input series and creates associated input/output pairs. Note that this function should input a) the series and b) the window length, and return the input/output subsequences. Make sure to format returned input/output as generally shown in table above (where window_size = 5), and make sure your returned input is a numpy array.\n\n-----",
"_____no_output_____"
],
[
"You can test your function on the list of odd numbers given below",
"_____no_output_____"
]
],
[
[
"odd_nums = np.array([1,3,5,7,9,11,13])",
"_____no_output_____"
]
],
[
[
"Here is a hard-coded solution for odd_nums. You can compare its results with what you get from your **window_transform_series** implementation.",
"_____no_output_____"
]
],
[
[
"# run a window of size 2 over the odd number sequence and display the results\nwindow_size = 2\n\nX = []\nX.append(odd_nums[0:2])\nX.append(odd_nums[1:3])\nX.append(odd_nums[2:4])\nX.append(odd_nums[3:5])\nX.append(odd_nums[4:6])\n\ny = odd_nums[2:]\n\nX = np.asarray(X)\ny = np.asarray(y)\ny = np.reshape(y, (len(y),1)) #optional\n\nassert(type(X).__name__ == 'ndarray')\nassert(type(y).__name__ == 'ndarray')\nassert(X.shape == (5,2))\nassert(y.shape in [(5,1), (5,)])\n\n# print out input/output pairs --> here input = X, corresponding output = y\nprint ('--- the input X will look like ----')\nprint (X)\n\nprint ('--- the associated output y will look like ----')\nprint (y)",
"--- the input X will look like ----\n[[ 1 3]\n [ 3 5]\n [ 5 7]\n [ 7 9]\n [ 9 11]]\n--- the associated output y will look like ----\n[[ 5]\n [ 7]\n [ 9]\n [11]\n [13]]\n"
]
],
[
[
"Again - you can check that your completed **window_transform_series** function works correctly by trying it on the odd_nums sequence - you should get the above output.",
"_____no_output_____"
]
],
[
[
"### DONE: implement the function window_transform_series in the file my_answers.py\nfrom my_answers import window_transform_series\n# X,y = window_transform_series(series = odd_nums,window_size = 2)\n# print(X)\n# print(y)",
"_____no_output_____"
]
],
[
[
"With this function in place apply it to the series in the Python cell below. We use a window_size = 7 for these experiments.",
"_____no_output_____"
]
],
[
[
"# window the data using your windowing function\nwindow_size = 7\nX,y = window_transform_series(series = dataset,window_size = window_size)",
"_____no_output_____"
]
],
[
[
"## 1.3 Splitting into training and testing sets\n\nIn order to perform proper testing on our dataset we will lop off the last 1/3 of it for validation (or testing). This is that once we train our model we have something to test it on (like any regression problem!). This splitting into training/testing sets is done in the cell below.\n\nNote how here we are **not** splitting the dataset *randomly* as one typically would do when validating a regression model. This is because our input/output pairs *are related temporally*. We don't want to validate our model by training on a random subset of the series and then testing on another random subset, as this simulates the scenario that we receive new points *within the timeframe of our training set*. \n\nWe want to train on one solid chunk of the series (in our case, the first full 2/3 of it), and validate on a later chunk (the last 1/3) as this simulates how we would predict *future* values of a time series.",
"_____no_output_____"
]
],
[
[
"# split our dataset into training / testing sets\ntrain_test_split = int(np.ceil(2*len(y)/float(3))) # set the split point\n\n# partition the training set\nX_train = X[:train_test_split,:]\ny_train = y[:train_test_split]\n\n# keep the last chunk for testing\nX_test = X[train_test_split:,:]\ny_test = y[train_test_split:]\n\n# X_test = np.delete(X_test, 0, 0)\n\n\n# NOTE: to use keras's RNN LSTM module our input must be reshaped to [samples, window size, stepsize] \nX_train = np.asarray(np.reshape(X_train, (X_train.shape[0], window_size, 1)))\nX_test = np.asarray(np.reshape(X_test, (X_test.shape[0], window_size, 1)))\n\nif len(X_test) != len(y_test):\n print('Warning: X_test is not the same size as y_test:', len(X_test), \"vs\", len(y_test))",
"_____no_output_____"
]
],
[
[
"<a id='TODO_2'></a>\n\n## 1.4 Build and run an RNN regression model\n\nHaving created input/output pairs out of our time series and cut this into training/testing sets, we can now begin setting up our RNN. We use Keras to quickly build a two hidden layer RNN of the following specifications\n\n- layer 1 uses an LSTM module with 5 hidden units (note here the input_shape = (window_size,1))\n- layer 2 uses a fully connected module with one unit\n- the 'mean_squared_error' loss should be used (remember: we are performing regression here)\n\nThis can be constructed using just a few lines - see e.g., the [general Keras documentation](https://keras.io/getting-started/sequential-model-guide/) and the [LSTM documentation in particular](https://keras.io/layers/recurrent/) for examples of how to quickly use Keras to build neural network models. Make sure you are initializing your optimizer given the [keras-recommended approach for RNNs](https://keras.io/optimizers/) \n\n(given in the cell below). (remember to copy your completed function into the script *my_answers.py* function titled *build_part1_RNN* before submitting your project)",
"_____no_output_____"
]
],
[
[
"### DONE: create required RNN model\n# import keras network libraries\nfrom keras.models import Sequential\nfrom keras.layers import Dense\nfrom keras.layers import LSTM\nimport keras\n\n# given - fix random seed - so we can all reproduce the same results on our default time series\nnp.random.seed(0)\n\n# DONE: implement build_part1_RNN in my_answers.py\nfrom my_answers import build_part1_RNN\nmodel = build_part1_RNN(window_size)\n\n# build model using keras documentation recommended optimizer initialization\noptimizer = keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)\n\n# compile the model\nmodel.compile(loss='mean_squared_error', optimizer=optimizer)",
"_____no_output_____"
]
],
[
[
"With your model built you can now fit the model by activating the cell below! Note: the number of epochs (np_epochs) and batch_size are preset (so we can all produce the same results). You can choose to toggle the verbose parameter - which gives you regular updates on the progress of the algorithm - on and off by setting it to 1 or 0 respectively.",
"_____no_output_____"
]
],
[
[
"# run your model!\nmodel.fit(X_train, y_train, epochs=1000, batch_size=256, verbose=0)",
"_____no_output_____"
]
],
[
[
"## 1.5 Checking model performance\n\nWith your model fit we can now make predictions on both our training and testing sets.",
"_____no_output_____"
]
],
[
[
"# generate predictions for training\ntrain_predict = model.predict(X_train)\ntest_predict = model.predict(X_test)",
"_____no_output_____"
]
],
[
[
"In the next cell we compute training and testing errors using our trained model - you should be able to achieve at least\n\n*training_error* < 0.02\n\nand \n\n*testing_error* < 0.02\n\nwith your fully trained model. \n\nIf either or both of your accuracies are larger than 0.02 re-train your model - increasing the number of epochs you take (a maximum of around 1,000 should do the job) and/or adjusting your batch_size.",
"_____no_output_____"
]
],
[
[
"# print out training and testing errors\ntraining_error = model.evaluate(X_train, y_train, verbose=0)\nprint('training error = ' + str(training_error))\n\ntesting_error = model.evaluate(X_test, y_test, verbose=0)\nprint('testing error = ' + str(testing_error))",
"training error = 0.0158862119371\ntesting error = 0.0146829202381\n"
]
],
[
[
"Activating the next cell plots the original data, as well as both predictions on the training and testing sets. ",
"_____no_output_____"
]
],
[
[
"### Plot everything - the original series as well as predictions on training and testing sets\nimport matplotlib.pyplot as plt\n%matplotlib inline\n\n# plot original series\nplt.plot(dataset,color = 'k')\n\n# plot training set prediction\nsplit_pt = train_test_split + window_size \nplt.plot(np.arange(window_size,split_pt,1),train_predict,color = 'b')\n\n# plot testing set prediction\nplt.plot(np.arange(split_pt,split_pt + len(test_predict),1),test_predict,color = 'r')\n\n# pretty up graph\nplt.xlabel('day')\nplt.ylabel('(normalized) price of Apple stock')\nplt.legend(['original series','training fit','testing fit'],loc='center left', bbox_to_anchor=(1, 0.5))\nplt.show()",
"_____no_output_____"
]
],
[
[
"**Note:** you can try out any time series for this exercise! If you would like to try another see e.g., [this site containing thousands of time series](https://datamarket.com/data/list/?q=provider%3Atsdl) and pick another one!",
"_____no_output_____"
],
[
"# Problem 2: Create a sequence generator",
"_____no_output_____"
],
[
"## 2.1 Getting started\n\nIn this project you will implement a popular Recurrent Neural Network (RNN) architecture to create an English language sequence generator capable of building semi-coherent English sentences from scratch by building them up character-by-character. This will require a substantial amount amount of parameter tuning on a large training corpus (at least 100,000 characters long). In particular for this project we will be using a complete version of Sir Arthur Conan Doyle's classic book The Adventures of Sherlock Holmes.\n\nHow can we train a machine learning model to generate text automatically, character-by-character? *By showing the model many training examples so it can learn a pattern between input and output.* With this type of text generation each input is a string of valid characters like this one\n\n*dogs are grea*\n\nwhile the corresponding output is the next character in the sentence - which here is 't' (since the complete sentence is 'dogs are great'). We need to show a model many such examples in order for it to make reasonable predictions.\n\n**Fun note:** For those interested in how text generation is being used check out some of the following fun resources:\n\n- [Generate wacky sentences](http://www.cs.toronto.edu/~ilya/rnn.html) with this academic RNN text generator\n\n- Various twitter bots that tweet automatically generated text like[this one](http://tweet-generator-alex.herokuapp.com/).\n\n- the [NanoGenMo](https://github.com/NaNoGenMo/2016) annual contest to automatically produce a 50,000+ novel automatically\n\n- [Robot Shakespeare](https://github.com/genekogan/RobotShakespeare) a text generator that automatically produces Shakespear-esk sentences",
"_____no_output_____"
],
[
"## 2.2 Preprocessing a text dataset\n\nOur first task is to get a large text corpus for use in training, and on it we perform a several light pre-processing tasks. The default corpus we will use is the classic book Sherlock Holmes, but you can use a variety of others as well - so long as they are fairly large (around 100,000 characters or more). ",
"_____no_output_____"
]
],
[
[
"# read in the text, transforming everything to lower case\ntext = open('datasets/holmes.txt').read().lower()\nprint('our original text has ' + str(len(text)) + ' characters')",
"our original text has 581864 characters\n"
]
],
[
[
"Next, lets examine a bit of the raw text. Because we are interested in creating sentences of English words automatically by building up each word character-by-character, we only want to train on valid English words. In other words - we need to remove all of the other characters that are not part of English words.",
"_____no_output_____"
]
],
[
[
"### print out the first 1000 characters of the raw text to get a sense of what we need to throw out\ntext[:2000]",
"_____no_output_____"
]
],
[
[
"Wow - there's a lot of junk here (i.e., weird uncommon character combinations - as this first character chunk contains the title and author page, as well as table of contents)! To keep things simple, we want to train our RNN on a large chunk of more typical English sentences - we don't want it to start thinking non-english words or strange characters are valid! - so lets clean up the data a bit.\n\nFirst, since the dataset is so large and the first few hundred characters contain a lot of junk, lets cut it out. Lets also find-and-replace those newline tags with empty spaces.",
"_____no_output_____"
]
],
[
[
"### find and replace '\\n' and '\\r' symbols - replacing them \ntext = text[1302:]\ntext = text.replace('\\n',' ') # replacing '\\n' with '' simply removes the sequence\ntext = text.replace('\\r',' ')",
"_____no_output_____"
]
],
[
[
"Lets see how the first 1000 characters of our text looks now!",
"_____no_output_____"
]
],
[
[
"### print out the first 1000 characters of the raw text to get a sense of what we need to throw out\ntext[:1000]",
"_____no_output_____"
]
],
[
[
"<a id='TODO_3'></a>\n\n#### TODO: finish cleaning the text\n\nLets make sure we haven't left any other atypical characters (commas, periods, etc., are ok) lurking around in the depths of the text. You can do this by enumerating all the text's unique characters, examining them, and then replacing any unwanted characters with empty spaces! Once we find all of the text's unique characters, we can remove all of the atypical ones in the next cell. Note: don't remove the punctuation marks given in my_answers.py.",
"_____no_output_____"
]
],
[
[
"### DONE: implement cleaned_text in my_answers.py\nfrom my_answers import cleaned_text\n\ntext = cleaned_text(text)\n\n# shorten any extra dead space created above\ntext = text.replace(' ',' ')",
"_____no_output_____"
]
],
[
[
"With your chosen characters removed print out the first few hundred lines again just to double check that everything looks good.",
"_____no_output_____"
]
],
[
[
"### print out the first 2000 characters of the raw text to get a sense of what we need to throw out\ntext[:2000]",
"_____no_output_____"
]
],
[
[
"Now that we have thrown out a good number of non-English characters/character sequences lets print out some statistics about the dataset - including number of total characters and number of unique characters.",
"_____no_output_____"
]
],
[
[
"# count the number of unique characters in the text\nchars = sorted(list(set(text)))\n\n# print some of the text, as well as statistics\nprint (\"this corpus has \" + str(len(text)) + \" total number of characters\")\nprint (\"this corpus has \" + str(len(chars)) + \" unique characters\")\nprint(chars)",
"this corpus has 569169 total number of characters\nthis corpus has 33 unique characters\n[' ', '!', ',', '.', ':', ';', '?', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n"
]
],
[
[
"## 2.3 Cutting data into input/output pairs\n\nNow that we have our text all cleaned up, how can we use it to train a model to generate sentences automatically? First we need to train a machine learning model - and in order to do that we need a set of input/output pairs for a model to train on. How can we create a set of input/output pairs from our text to train on?\n\nRemember in part 1 of this notebook how we used a sliding window to extract input/output pairs from a time series? We do the same thing here! We slide a window of length $T$ along our giant text corpus - everything in the window becomes one input while the character following becomes its corresponding output. This process of extracting input/output pairs is illustrated in the gif below on a small example text using a window size of T = 5.\n\n<img src=\"images/text_windowing_training.gif\" width=400 height=400/>\n\nNotice one aspect of the sliding window in this gif that does not mirror the analogous gif for time series shown in part 1 of the notebook - we do not need to slide the window along one character at a time but can move by a fixed step size $M$ greater than 1 (in the gif indeed $M = 1$). This is done with large input texts (like ours which has over 500,000 characters!) when sliding the window along one character at a time we would create far too many input/output pairs to be able to reasonably compute with.\n\nMore formally lets denote our text corpus - which is one long string of characters - as follows\n\n$$s_{0},s_{1},s_{2},...,s_{P}$$\n\nwhere $P$ is the length of the text (again for our text $P \\approx 500,000!$). Sliding a window of size T = 5 with a step length of M = 1 (these are the parameters shown in the gif above) over this sequence produces the following list of input/output pairs\n\n\n$$\\begin{array}{c|c}\n\\text{Input} & \\text{Output}\\\\\n\\hline \\color{CornflowerBlue} {\\langle s_{1},s_{2},s_{3},s_{4},s_{5}\\rangle} & \\color{Goldenrod}{ s_{6}} \\\\\n\\ \\color{CornflowerBlue} {\\langle s_{2},s_{3},s_{4},s_{5},s_{6} \\rangle } & \\color{Goldenrod} {s_{7} } \\\\\n\\color{CornflowerBlue} {\\vdots} & \\color{Goldenrod} {\\vdots}\\\\\n\\color{CornflowerBlue} { \\langle s_{P-5},s_{P-4},s_{P-3},s_{P-2},s_{P-1} \\rangle } & \\color{Goldenrod} {s_{P}}\n\\end{array}$$\n\nNotice here that each input is a sequence (or vector) of 5 characters (and in general has length equal to the window size T) while each corresponding output is a single character. We created around P total number of input/output pairs (for general step size M we create around ceil(P/M) pairs).",
"_____no_output_____"
],
[
"<a id='TODO_4'></a>\n\nNow its time for you to window the input time series as described above! \n\n**TODO:** Create a function that runs a sliding window along the input text and creates associated input/output pairs. A skeleton function has been provided for you. Note that this function should input a) the text b) the window size and c) the step size, and return the input/output sequences. Note: the return items should be *lists* - not numpy arrays.\n\n(remember to copy your completed function into the script *my_answers.py* function titled *window_transform_text* before submitting your project)",
"_____no_output_____"
]
],
[
[
"### DONE: implement window_transform_series in my_answers.py\nfrom my_answers import window_transform_text",
"_____no_output_____"
]
],
[
[
"With our function complete we can now use it to produce input/output pairs! We employ the function in the next cell, where the window_size = 50 and step_size = 5.",
"_____no_output_____"
]
],
[
[
"# run your text window-ing function \nwindow_size = 100\nstep_size = 5\ninputs, outputs = window_transform_text(text,window_size,step_size)",
"_____no_output_____"
],
[
"# from my_answers import window_transform_text\n# nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]\n# print(nums)\n# a,b = window_transform_text(text = nums,window_size = 5, step_size=2)\n# print(a)\n# print(b)",
"_____no_output_____"
]
],
[
[
"Lets print out a few input/output pairs to verify that we have made the right sort of stuff!",
"_____no_output_____"
]
],
[
[
"# print out a few of the input/output pairs to verify that we've made the right kind of stuff to learn from\nprint('input =', inputs[2])\nprint('output =', outputs[2])\nprint('--------------')\nprint('input =', inputs[100])\nprint('output =', outputs[100])",
"input = e eclipses and predominates the whole of her sex. it was not that he felt any emotion akin to love f\noutput = o\n--------------\ninput = erexcellent for drawing the veil from mens motives and actions. but for the trained reasoner to admi\noutput = t\n"
]
],
[
[
"Looks good!",
"_____no_output_____"
],
[
"## 2.4 Wait, what kind of problem is text generation again?\n\nIn part 1 of this notebook we used the same pre-processing technique - the sliding window - to produce a set of training input/output pairs to tackle the problem of time series prediction *by treating the problem as one of regression*. So what sort of problem do we have here now, with text generation? Well, the time series prediction was a regression problem because the output (one value of the time series) was a continuous value. Here - for character-by-character text generation - each output is a *single character*. This isn't a continuous value - but a distinct class - therefore **character-by-character text generation is a classification problem**. \n\nHow many classes are there in the data? Well, the number of classes is equal to the number of unique characters we have to predict! How many of those were there in our dataset again? Lets print out the value again.",
"_____no_output_____"
]
],
[
[
"# print out the number of unique characters in the dataset\nchars = sorted(list(set(text)))\nprint (\"this corpus has \" + str(len(chars)) + \" unique characters\")\nprint ('and these characters are ')\nprint (chars)",
"this corpus has 33 unique characters\nand these characters are \n[' ', '!', ',', '.', ':', ';', '?', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']\n"
]
],
[
[
"Rockin' - so we have a multiclass classification problem on our hands!",
"_____no_output_____"
],
[
"## 2.5 One-hot encoding characters\n\nThe last issue we have to deal with is representing our text data as numerical data so that we can use it as an input to a neural network. One of the conceptually simplest ways of doing this is via a 'one-hot encoding' scheme. Here's how it works.\n\nWe transform each character in our inputs/outputs into a vector with length equal to the number of unique characters in our text. This vector is all zeros except one location where we place a 1 - and this location is unique to each character type. e.g., we transform 'a', 'b', and 'c' as follows\n\n$$a\\longleftarrow\\left[\\begin{array}{c}\n1\\\\\n0\\\\\n0\\\\\n\\vdots\\\\\n0\\\\\n0\n\\end{array}\\right]\\,\\,\\,\\,\\,\\,\\,b\\longleftarrow\\left[\\begin{array}{c}\n0\\\\\n1\\\\\n0\\\\\n\\vdots\\\\\n0\\\\\n0\n\\end{array}\\right]\\,\\,\\,\\,\\,c\\longleftarrow\\left[\\begin{array}{c}\n0\\\\\n0\\\\\n1\\\\\n\\vdots\\\\\n0\\\\\n0 \n\\end{array}\\right]\\cdots$$\n\nwhere each vector has 32 entries (or in general: number of entries = number of unique characters in text).",
"_____no_output_____"
],
[
"The first practical step towards doing this one-hot encoding is to form a dictionary mapping each unique character to a unique integer, and one dictionary to do the reverse mapping. We can then use these dictionaries to quickly make our one-hot encodings, as well as re-translate (from integers to characters) the results of our trained RNN classification model.",
"_____no_output_____"
]
],
[
[
"# this dictionary is a function mapping each unique character to a unique integer\nchars_to_indices = dict((c, i) for i, c in enumerate(chars)) # map each unique character to unique integer\n\n# this dictionary is a function mapping each unique integer back to a unique character\nindices_to_chars = dict((i, c) for i, c in enumerate(chars)) # map each unique integer back to unique character",
"_____no_output_____"
]
],
[
[
"Now we can transform our input/output pairs - consisting of characters - to equivalent input/output pairs made up of one-hot encoded vectors. In the next cell we provide a function for doing just this: it takes in the raw character input/outputs and returns their numerical versions. In particular the numerical input is given as $\\bf{X}$, and numerical output is given as the $\\bf{y}$",
"_____no_output_____"
]
],
[
[
"# transform character-based input/output into equivalent numerical versions\ndef encode_io_pairs(text,window_size,step_size):\n # number of unique chars\n chars = sorted(list(set(text)))\n num_chars = len(chars)\n \n # cut up text into character input/output pairs\n inputs, outputs = window_transform_text(text,window_size,step_size)\n \n # create empty vessels for one-hot encoded input/output\n X = np.zeros((len(inputs), window_size, num_chars), dtype=np.bool)\n y = np.zeros((len(inputs), num_chars), dtype=np.bool)\n \n # loop over inputs/outputs and transform and store in X/y\n for i, sentence in enumerate(inputs):\n for t, char in enumerate(sentence):\n X[i, t, chars_to_indices[char]] = 1\n current_output = outputs[i]\n current_char = chars_to_indices[current_output]\n y[i, current_char] = 1\n \n return X,y",
"_____no_output_____"
]
],
[
[
"Now run the one-hot encoding function by activating the cell below and transform our input/output pairs!",
"_____no_output_____"
]
],
[
[
"# use your function\nwindow_size = 100\nstep_size = 5\nX,y = encode_io_pairs(text,window_size,step_size)",
"_____no_output_____"
]
],
[
[
"<a id='TODO_5'></a>\n\n## 2.6 Setting up our RNN\n\nWith our dataset loaded and the input/output pairs extracted / transformed we can now begin setting up our RNN for training. Again we will use Keras to quickly build a single hidden layer RNN - where our hidden layer consists of LSTM modules.\n\nTime to get to work: build a 3 layer RNN model of the following specification\n\n- layer 1 should be an LSTM module with 200 hidden units --> note this should have input_shape = (window_size,len(chars)) where len(chars) = number of unique characters in your cleaned text\n- layer 2 should be a linear module, fully connected, with len(chars) hidden units --> where len(chars) = number of unique characters in your cleaned text\n- layer 3 should be a softmax activation ( since we are solving a *multiclass classification*)\n- Use the **categorical_crossentropy** loss \n\nThis network can be constructed using just a few lines - as with the RNN network you made in part 1 of this notebook. See e.g., the [general Keras documentation](https://keras.io/getting-started/sequential-model-guide/) and the [LSTM documentation in particular](https://keras.io/layers/recurrent/) for examples of how to quickly use Keras to build neural network models.",
"_____no_output_____"
]
],
[
[
"### necessary functions from the keras library\nfrom keras.models import Sequential\nfrom keras.layers import Dense, Activation, LSTM\nfrom keras.optimizers import RMSprop\nfrom keras.utils.data_utils import get_file\nimport keras\nimport random\n\n# DONE implement build_part2_RNN in my_answers.py\nfrom my_answers import build_part2_RNN\n\nmodel = build_part2_RNN(window_size, len(chars))\n\n# initialize optimizer\noptimizer = keras.optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)\n\n# compile model --> make sure initialized optimizer and callbacks - as defined above - are used\nmodel.compile(loss='categorical_crossentropy', optimizer=optimizer)",
"_____no_output_____"
]
],
[
[
"## 2.7 Training our RNN model for text generation\n\nWith our RNN setup we can now train it! Lets begin by trying it out on a small subset of the larger version. In the next cell we take the first 10,000 input/output pairs from our training database to learn on.",
"_____no_output_____"
]
],
[
[
"# a small subset of our input/output pairs\nXsmall = X[:10000,:,:]\nysmall = y[:10000,:]",
"_____no_output_____"
]
],
[
[
"Now lets fit our model!",
"_____no_output_____"
]
],
[
[
"# train the model\nmodel.fit(Xsmall, ysmall, batch_size=500, epochs=40,verbose = 1)\n\n# save weights\nmodel.save_weights('model_weights/best_RNN_small_textdata_weights.hdf5')",
"_____no_output_____"
]
],
[
[
"How do we make a given number of predictions (characters) based on this fitted model? \n\nFirst we predict the next character after following any chunk of characters in the text of length equal to our chosen window size. Then we remove the first character in our input sequence and tack our prediction onto the end. This gives us a slightly changed sequence of inputs that still has length equal to the size of our window. We then feed in this updated input sequence into the model to predict the another character. Together then we have two predicted characters following our original input sequence. Repeating this process N times gives us N predicted characters.\n\nIn the next Python cell we provide you with a completed function that does just this - it makes predictions when given a) a trained RNN model, b) a subset of (window_size) characters from the text, and c) a number of characters to predict (to follow our input subset).",
"_____no_output_____"
]
],
[
[
"# function that uses trained model to predict a desired number of future characters\ndef predict_next_chars(model,input_chars,num_to_predict): \n # create output\n predicted_chars = ''\n for i in range(num_to_predict):\n # convert this round's predicted characters to numerical input \n x_test = np.zeros((1, window_size, len(chars)))\n for t, char in enumerate(input_chars):\n x_test[0, t, chars_to_indices[char]] = 1.\n\n # make this round's prediction\n test_predict = model.predict(x_test,verbose = 0)[0]\n\n # translate numerical prediction back to characters\n r = np.argmax(test_predict) # predict class of each test input\n d = indices_to_chars[r] \n\n # update predicted_chars and input\n predicted_chars+=d\n input_chars+=d\n input_chars = input_chars[1:]\n return predicted_chars",
"_____no_output_____"
],
[
"# import os\n# os.remove('model_weights/best_RNN_small_textdata_weights.hdf5')\n# f = open('model_weights/best_RNN_small_textdata_weights.hdf5', 'w')\n# f.close()\n# model.save_weights('model_weights/best_RNN_small_textdata_weights.hdf5')",
"_____no_output_____"
]
],
[
[
"<a id='TODO_6'></a>\n\nWith your trained model try a few subsets of the complete text as input - note the length of each must be exactly equal to the window size. For each subset use the function above to predict the next 100 characters that follow each input.",
"_____no_output_____"
]
],
[
[
"# DONE: choose an input sequence and use the prediction function in the previous Python cell to predict 100 characters following it\n# get an appropriately sized chunk of characters from the text\nstart_inds = [0, 1, 2, 3, 4, 5]\n\n# load in weights\nmodel.load_weights('model_weights/best_RNN_small_textdata_weights.hdf5')\nfor s in start_inds:\n start_index = s\n input_chars = text[start_index: start_index + window_size]\n\n # use the prediction function\n predict_input = predict_next_chars(model,input_chars,num_to_predict = 100)\n\n # print out input characters\n print('------------------')\n input_line = 'input chars = ' + '\\n' + input_chars + '\"' + '\\n'\n print(input_line)\n\n # print out predicted characters\n line = 'predicted chars = ' + '\\n' + predict_input + '\"' + '\\n'\n print(line)",
"------------------\ninput chars = \nis eyes she eclipses and predominates the whole of her sex it was not that he felt any emotion akin \"\n\npredicted chars = \nthe rast in i shand your se the erade a dore wioh hur wat the werl what the enter wat the kend out a\"\n\n------------------\ninput chars = \ns eyes she eclipses and predominates the whole of her sex it was not that he felt any emotion akin t\"\n\npredicted chars = \nhe rast in i shand your se the erade a dore wioh hur wat the werl what the enter wat the kend out a \"\n\n------------------\ninput chars = \n eyes she eclipses and predominates the whole of her sex it was not that he felt any emotion akin to\"\n\npredicted chars = \n eat a cous and she sing thand y uren be in not and recone forn he parked werthen i surmand and sere\"\n\n------------------\ninput chars = \neyes she eclipses and predominates the whole of her sex it was not that he felt any emotion akin to \"\n\npredicted chars = \neat a cous and she sing thand y uren be in not and recone forn he parked werthen i surmand and seres\"\n\n------------------\ninput chars = \nyes she eclipses and predominates the whole of her sex it was not that he felt any emotion akin to l\"\n\npredicted chars = \nath beet ant in in the forn of mas of the ofrthar and i sound he she wald i mald you tay westly thin\"\n\n------------------\ninput chars = \nes she eclipses and predominates the whole of her sex it was not that he felt any emotion akin to lo\"\n\npredicted chars = \nve wist out ave the your and hersend how selleeted and wis leat he west cuand it hes latt of hall we\"\n\n"
]
],
[
[
"This looks ok, but not great. Now lets try the same experiment with a larger chunk of the data - with the first 100,000 input/output pairs. \n\nTuning RNNs for a typical character dataset like the one we will use here is a computationally intensive endeavour and thus timely on a typical CPU. Using a reasonably sized cloud-based GPU can speed up training by a factor of 10. Also because of the long training time it is highly recommended that you carefully write the output of each step of your process to file. This is so that all of your results are saved even if you close the web browser you're working out of, as the processes will continue processing in the background but variables/output in the notebook system will not update when you open it again.\n\nIn the next cell we show you how to create a text file in Python and record data to it. This sort of setup can be used to record your final predictions.",
"_____no_output_____"
]
],
[
[
"### A simple way to write output to file\nf = open('my_test_output.txt', 'w') # create an output file to write too\nf.write('this is only a test ' + '\\n') # print some output text\nx = 2\nf.write('the value of x is ' + str(x) + '\\n') # record a variable value\nf.close() \n\n# print out the contents of my_test_output.txt\nf = open('my_test_output.txt', 'r') # create an output file to write too\nf.read()",
"_____no_output_____"
]
],
[
[
"With this recording devices we can now more safely perform experiments on larger portions of the text. In the next cell we will use the first 100,000 input/output pairs to train our RNN model.",
"_____no_output_____"
],
[
"First we fit our model to the dataset, then generate text using the trained model in precisely the same generation method applied before on the small dataset.\n\n**Note:** your generated words should be - by and large - more realistic than with the small dataset, but you won't be able to generate perfect English sentences even with this amount of data. A rule of thumb: your model is working well if you generate sentences that largely contain real English words.",
"_____no_output_____"
]
],
[
[
"# a small subset of our input/output pairs\nXlarge = X[:100000,:,:]\nylarge = y[:100000,:]\n\n# DONE: fit to our larger dataset\nmodel.fit(Xlarge, ylarge, batch_size=500, epochs=30, verbose=1)\n\n# save weights\nmodel.save_weights('model_weights/best_RNN_large_textdata_weights.hdf5')",
"Epoch 1/30\n100000/100000 [==============================] - 45s - loss: 1.9659 \nEpoch 2/30\n100000/100000 [==============================] - 45s - loss: 1.8361 \nEpoch 3/30\n100000/100000 [==============================] - 45s - loss: 1.7759 \nEpoch 4/30\n100000/100000 [==============================] - 45s - loss: 1.7261 \nEpoch 5/30\n100000/100000 [==============================] - 45s - loss: 1.6827 \nEpoch 6/30\n100000/100000 [==============================] - 45s - loss: 1.6443 \nEpoch 7/30\n100000/100000 [==============================] - 45s - loss: 1.6072 \nEpoch 8/30\n100000/100000 [==============================] - 45s - loss: 1.5736 \nEpoch 9/30\n100000/100000 [==============================] - 45s - loss: 1.5099 \nEpoch 11/30\n100000/100000 [==============================] - 45s - loss: 1.4795 \nEpoch 12/30\n100000/100000 [==============================] - 45s - loss: 1.4496 \nEpoch 13/30\n100000/100000 [==============================] - 45s - loss: 1.4202 \nEpoch 14/30\n100000/100000 [==============================] - 45s - loss: 1.3912 \nEpoch 15/30\n100000/100000 [==============================] - 45s - loss: 1.3615 \nEpoch 16/30\n100000/100000 [==============================] - 45s - loss: 1.3341 \nEpoch 17/30\n100000/100000 [==============================] - 45s - loss: 1.3052 \nEpoch 18/30\n100000/100000 [==============================] - 45s - loss: 1.2783 \nEpoch 19/30\n100000/100000 [==============================] - 45s - loss: 1.2501 \nEpoch 20/30\n100000/100000 [==============================] - 45s - loss: 1.2210 \nEpoch 21/30\n100000/100000 [==============================] - 45s - loss: 1.1942 \nEpoch 22/30\n100000/100000 [==============================] - 45s - loss: 1.1659 \nEpoch 23/30\n100000/100000 [==============================] - 45s - loss: 1.1374 \nEpoch 24/30\n100000/100000 [==============================] - 45s - loss: 1.1111 \nEpoch 25/30\n100000/100000 [==============================] - 45s - loss: 1.0837 \nEpoch 26/30\n100000/100000 [==============================] - 45s - loss: 1.0580 \nEpoch 27/30\n100000/100000 [==============================] - 45s - loss: 1.0310 \nEpoch 28/30\n100000/100000 [==============================] - 45s - loss: 1.0057 \nEpoch 29/30\n100000/100000 [==============================] - 45s - loss: 0.9826 \nEpoch 30/30\n100000/100000 [==============================] - 45s - loss: 0.9573 \n"
],
[
"# DONE: choose an input sequence and use the prediction function in the previous Python cell to predict 100 characters following it\n# get an appropriately sized chunk of characters from the text\nstart_inds = [0, 2, 10, 12, 20, 22, 1000, 1002]\n\n# save output\nf = open('text_gen_output/RNN_large_textdata_output.txt', 'w') # create an output file to write too\n\n# load weights\nmodel.load_weights('model_weights/best_RNN_large_textdata_weights.hdf5')\nfor s in start_inds:\n start_index = s\n input_chars = text[start_index: start_index + window_size]\n\n # use the prediction function\n predict_input = predict_next_chars(model,input_chars,num_to_predict = 100)\n\n # print out input characters\n line = '-------------------' + '\\n'\n print(line)\n f.write(line)\n\n input_line = 'input chars = ' + '\\n' + input_chars + '\"' + '\\n'\n print(input_line)\n f.write(input_line)\n\n # print out predicted characters\n predict_line = 'predicted chars = ' + '\\n' + predict_input + '\"' + '\\n'\n print(predict_line)\n f.write(predict_line)\nf.close()",
"-------------------\n\ninput chars = \nis eyes she eclipses and predominates the whole of her sex it was not that he felt any emotion akin \"\n\npredicted chars = \nthen i have are morning beatul solly of the business he was a small dood and ras elles he sherked hi\"\n\n-------------------\n\ninput chars = \n eyes she eclipses and predominates the whole of her sex it was not that he felt any emotion akin to\"\n\npredicted chars = \n and heard it is a shill contrceet when i am all dishe for arl to be the door what a come is the loo\"\n\n-------------------\n\ninput chars = \ne eclipses and predominates the whole of her sex it was not that he felt any emotion akin to love fo\"\n\npredicted chars = \nr a from assion was the sell and of the roon which he had not heard but i could not bes it the stree\"\n\n-------------------\n\ninput chars = \neclipses and predominates the whole of her sex it was not that he felt any emotion akin to love for \"\n\npredicted chars = \na from assion was the sell and of the roon which he had not heard but i could not bes it the street \"\n\n-------------------\n\ninput chars = \n and predominates the whole of her sex it was not that he felt any emotion akin to love for irene ad\"\n\npredicted chars = \nlerest into the last he was maded by and she of carder instrance it is an ins and he as it is in pre\"\n\n-------------------\n\ninput chars = \nnd predominates the whole of her sex it was not that he felt any emotion akin to love for irene adle\"\n\npredicted chars = \nrest into the last he was maded by and she of carder instrance it is an ins and he as it is in preca\"\n\n-------------------\n\ninput chars = \nstionable memory i had seen little of holmes lately my marriage had drifted us away from each other \"\n\npredicted chars = \nmorther and i have no dound me morner a stall man who should he as in the string of it was the paste\"\n\n-------------------\n\ninput chars = \nionable memory i had seen little of holmes lately my marriage had drifted us away from each other my\"\n\npredicted chars = \n hander them is a recoly to be offer there ase the onder of i have and i have no doubt that i have n\"\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",
"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"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"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"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code",
"code"
]
] |
ecec372c19e8f41f58307e621b4ad6694c78747b | 6,193 | ipynb | Jupyter Notebook | content/lessons/01-Intro/SmallGroup-Intro.ipynb | IST256/learn-python | b2373b5cf596a318976a816e3102cc704d6b9b57 | [
"MIT"
] | 14 | 2017-02-23T21:00:46.000Z | 2021-03-19T09:29:40.000Z | content/lessons/01-Intro/SmallGroup-Intro.ipynb | IST256/learn-python | b2373b5cf596a318976a816e3102cc704d6b9b57 | [
"MIT"
] | null | null | null | content/lessons/01-Intro/SmallGroup-Intro.ipynb | IST256/learn-python | b2373b5cf596a318976a816e3102cc704d6b9b57 | [
"MIT"
] | 38 | 2017-02-03T13:49:19.000Z | 2021-08-15T16:47:56.000Z | 27.043668 | 298 | 0.590182 | [
[
[
"# Now You Code In Class: Gathering Student Data\n\n\n## The Problem\n\nWrite a program which gathers student data such as name, email, gpa and major then prints out a student profile card with a layout EXACTLY like this:\n\n### Sample Output:\n\n```\n===== STUDENT PROFILE =====\nNAME : Michael Fudge\nEMAIL : [email protected]\nGPA : 4.0\nMAJOR : Information Studies\n```\n\nOf course your actual output of name, email, GPA and major, will vary based on the inputs, which is the point of programming in the first place! ",
"_____no_output_____"
],
[
"## Problem Analysis: \"Thinking About The Problem\"\n\nThe first thing we should do before writing ANY CODE is have a good understanding of the problem. After all you can't solve a problem in code unless you understand it first! \n\nAs part of your **practice** routine in this course, you will formalize your **understanding** of the problem by articulating:\n\n1. the data inputs into the program\n2. the information output from the program\n3. the algorithm - the high level steps from input to output. \n\nAgain, the purpose of this is to communicate your understanding of the problem **to your professor and more importantly yourself.** \n\nOf course, defining a problem this way is typically not an easy thing to do, which is why we will learn several **problem-solving approaches** in this class.\n",
"_____no_output_____"
],
[
"## Problem Solving Approach: Work Backwards \n\nThe **work-backwards** approach to problem solving is often used in science and mathematics. It works well when we have an idea of the program's output but are unclear how to start the program. It can be used in this case because we expect out of the program itself is clearly understood. \n\nThe approach is as follows:\n\n1. start with the output\n2. figure out which variables are used in the output (what part of the output changes versus stays the same - the changing parts use variables)\n3. keep working backwards until the variables become inputs.",
"_____no_output_____"
],
[
"### PROMPT 1: Start with the output\n\nWrite Python code to print the example output under the problem section exactly as shown:",
"_____no_output_____"
]
],
[
[
"# Code here\n",
"_____no_output_____"
]
],
[
[
"### PROMPT 2: Which aspects of the output should change?\n\nWhich aspects of the output should change and therefore be written using variables? Write a Python assignment statement for each variable assigning it the **exact** value from the output.\n",
"_____no_output_____"
]
],
[
[
"# Code here\n",
"_____no_output_____"
]
],
[
[
"### PROMPT 3: Re-write the code from prompt 1 to use your variables\n\nNow we re-write the code from prompt 1 but use variables instead. Try using f-strings as they provide the best formatting options.",
"_____no_output_____"
]
],
[
[
"# Code here\n",
"_____no_output_____"
]
],
[
[
"### PROMPT 4: What transformations are required to get the variables from input to output?\n\nAre there any transformations required of the variables from input to output? For example, you might input first name and last name separarely, then combine them to full name.",
"_____no_output_____"
]
],
[
[
"# Code here",
"_____no_output_____"
]
],
[
[
"### PROMPT 5: Finalize the inputs\n\ncombine prompts 3 and 4 into a single program, replace the initialized variables with Python inputs and prompts. ",
"_____no_output_____"
]
],
[
[
"# Code here... now its written!",
"_____no_output_____"
]
],
[
[
"## Step 1: Problem Analysis\n\nInputs: PROMPT 6\n\nOutputs: PROMPT 7\n\nAlgorithm (Steps in Program):\n\nPROMPT 8\n",
"_____no_output_____"
]
],
[
[
"# Step 2: Write code here\n\n\n",
"_____no_output_____"
],
[
"# run this code to turn in your work!\nfrom coursetools.submission import Submission\nSubmission().submit_now()",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
]
] |
ecec3d153b6a5ec700f9c00fea21bab697d4cbbe | 18,048 | ipynb | Jupyter Notebook | tensorflow/lite/g3doc/models/style_transfer/overview.ipynb | ZhuBaohe/tensorflow | 1114a0364ef38d81d7a34e262994cf771e3c9460 | [
"Apache-2.0"
] | 7 | 2018-04-12T07:48:57.000Z | 2021-12-03T12:35:02.000Z | tensorflow/lite/g3doc/models/style_transfer/overview.ipynb | jatinarora1/tensorflow | f91c1776370e0c81a2326eb33e86aadbb1063e72 | [
"Apache-2.0"
] | 6 | 2022-01-15T07:17:47.000Z | 2022-02-14T15:28:22.000Z | tensorflow/lite/g3doc/models/style_transfer/overview.ipynb | I-Hong/tensorflow | 4a1ae31d56c3c7f40232aace615945c29dcf9c38 | [
"Apache-2.0"
] | 2 | 2019-06-18T01:54:19.000Z | 2019-06-19T11:17:05.000Z | 36.534413 | 366 | 0.561946 | [
[
[
"##### Copyright 2019 The TensorFlow Authors.",
"_____no_output_____"
]
],
[
[
"#@title Licensed under the Apache License, Version 2.0 (the \"License\");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n# https://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an \"AS IS\" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.",
"_____no_output_____"
]
],
[
[
"# Artistic Style Transfer with TensorFlow Lite",
"_____no_output_____"
],
[
"<table class=\"tfo-notebook-buttons\" align=\"left\">\n <td>\n <a target=\"_blank\" href=\"https://www.tensorflow.org/lite/models/style_transfer/overview\"><img src=\"https://www.tensorflow.org/images/tf_logo_32px.png\" />View on TensorFlow.org</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://colab.research.google.com/github/tensorflow/tensorflow/blob/master/tensorflow/lite/g3doc/models/style_transfer/overview.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n </td>\n <td>\n <a target=\"_blank\" href=\"https://github.com/tensorflow/tensorflow/blob/master/tensorflow/lite/g3doc/models/style_transfer/overview.ipynb\"><img src=\"https://www.tensorflow.org/images/GitHub-Mark-32px.png\" />View source on GitHub</a>\n </td>\n <td>\n <a href=\"https://storage.googleapis.com/tensorflow_docs/tensorflow/tensorflow/lite/g3doc/models/style_transfer/overview.ipynb\"><img src=\"https://www.tensorflow.org/images/download_logo_32px.png\" />Download notebook</a>\n </td>\n</table>",
"_____no_output_____"
],
[
"One of the most exciting developments in deep learning to come out recently is [artistic style transfer](https://arxiv.org/abs/1508.06576), or the ability to create a new image, known as a [pastiche](https://en.wikipedia.org/wiki/Pastiche), based on two input images: one representing the artistic style and one representing the content.\n\n\n\nUsing this technique, we can generate beautiful new artworks in a range of styles.\n\n\n\nThis tutorial shows how to use a pre-trained TensorFlow Lite model to apply style transfer on any pair of content and style image. You can use the pre-trained model to add style transfer to your own mobile applications.\n\nThe model is open-sourced on [GitHub](https://github.com/tensorflow/magenta/tree/master/magenta/models/arbitrary_image_stylization#train-a-model-on-a-large-dataset-with-data-augmentation-to-run-on-mobile). You can retrain the model with different parameters (e.g. increase content layers' weights to make the output image look more like the content image).",
"_____no_output_____"
],
[
"## Understand the model architecture",
"_____no_output_____"
],
[
"\n\nThis Artistic Style Transfer model consists of two submodels:\n1. **Style Prediciton Model**: A MobilenetV2-based neural network that takes an input style image to a 100-dimension style bottleneck vector.\n1. **Style Transform Model**: A neural network that takes apply a style bottleneck vector to a content image and creates a stylized image.\n\nIf your app only needs to support a fixed set of style images, you can compute their style bottleneck vectors in advance, and exclude the Style Prediction Model from your app's binary.",
"_____no_output_____"
],
[
"## Setup",
"_____no_output_____"
],
[
"Import dependencies.",
"_____no_output_____"
]
],
[
[
"from __future__ import absolute_import, division, print_function, unicode_literals",
"_____no_output_____"
],
[
"try:\n # %tensorflow_version only exists in Colab.\n import tensorflow.compat.v2 as tf\nexcept Exception:\n pass\ntf.enable_v2_behavior()",
"_____no_output_____"
],
[
"import IPython.display as display\n\nimport matplotlib.pyplot as plt\nimport matplotlib as mpl\nmpl.rcParams['figure.figsize'] = (12,12)\nmpl.rcParams['axes.grid'] = False\n\nimport numpy as np\nimport time\nimport functools",
"_____no_output_____"
]
],
[
[
"Download the content and style images, and the pre-trained TensorFlow Lite models.",
"_____no_output_____"
]
],
[
[
"content_path = tf.keras.utils.get_file('belfry.jpg','https://storage.googleapis.com/khanhlvg-public.appspot.com/arbitrary-style-transfer/belfry-2611573_1280.jpg')\nstyle_path = tf.keras.utils.get_file('style23.jpg','https://storage.googleapis.com/khanhlvg-public.appspot.com/arbitrary-style-transfer/style23.jpg')\n\nstyle_predict_path = tf.keras.utils.get_file('style_predict.tflite', 'https://storage.googleapis.com/download.tensorflow.org/models/tflite/arbitrary_style_transfer/style_predict_quantized_256.tflite')\nstyle_transform_path = tf.keras.utils.get_file('style_transform.tflite', 'https://storage.googleapis.com/download.tensorflow.org/models/tflite/arbitrary_style_transfer/style_transfer_quantized_dynamic.tflite')",
"_____no_output_____"
]
],
[
[
"## Pre-process the inputs\n\n* The content image and the style image must be RGB images with pixel values being float32 numbers between [0..1].\n* The style image size must be (1, 256, 256, 3). We central crop the image and resize it.\n* The content image can be any size. However, as we trained the model using square-cropped data, cropping the content image to a square results in better stylized image.",
"_____no_output_____"
]
],
[
[
"# Function to load an image from a file, and add a batch dimension.\ndef load_img(path_to_img):\n img = tf.io.read_file(path_to_img)\n img = tf.image.decode_image(img, channels=3)\n img = tf.image.convert_image_dtype(img, tf.float32)\n img = img[tf.newaxis, :]\n\n return img\n\n# Function to pre-process style image input.\ndef preprocess_style_image(style_image):\n # Resize the image so that the shorter dimension becomes 256px.\n target_dim = 256\n shape = tf.cast(tf.shape(style_image)[1:-1], tf.float32)\n short_dim = min(shape)\n scale = target_dim / short_dim\n new_shape = tf.cast(shape * scale, tf.int32)\n style_image = tf.image.resize(style_image, new_shape)\n\n # Central crop the image.\n style_image = tf.image.resize_with_crop_or_pad(style_image, target_dim, target_dim)\n\n return style_image\n\n# Function to pre-process content image input.\ndef preprocess_content_image(content_image):\n # Central crop the image.\n shape = tf.shape(content_image)[1:-1]\n short_dim = min(shape)\n content_image = tf.image.resize_with_crop_or_pad(content_image, short_dim, short_dim)\n\n return content_image\n\n# Load the input images.\ncontent_image = load_img(content_path)\nstyle_image = load_img(style_path)\n\n# Preprocess the input images.\npreprocessed_content_image = preprocess_content_image(content_image)\npreprocessed_style_image = preprocess_style_image(style_image)\n\nprint('Style Image Shape:', preprocessed_style_image.shape)\nprint('Content Image Shape:', preprocessed_content_image.shape)",
"_____no_output_____"
]
],
[
[
"## Visualize the inputs",
"_____no_output_____"
]
],
[
[
"def imshow(image, title=None):\n if len(image.shape) > 3:\n image = tf.squeeze(image, axis=0)\n\n plt.imshow(image)\n if title:\n plt.title(title)\n\nplt.subplot(1, 2, 1)\nimshow(preprocessed_content_image, 'Content Image')\n\nplt.subplot(1, 2, 2)\nimshow(preprocessed_style_image, 'Style Image')",
"_____no_output_____"
]
],
[
[
"## Run style transfer with TensorFlow Lite",
"_____no_output_____"
],
[
"### Style prediction",
"_____no_output_____"
]
],
[
[
"# Function to run style prediction on preprocessed style image.\ndef run_style_predict(preprocessed_style_image):\n # Load the model.\n interpreter = tf.lite.Interpreter(model_path=style_predict_path)\n\n # Set model input.\n interpreter.allocate_tensors()\n input_details = interpreter.get_input_details()\n interpreter.set_tensor(input_details[0][\"index\"], preprocessed_style_image)\n\n # Calculate style bottleneck.\n interpreter.invoke()\n style_bottleneck = interpreter.tensor(\n interpreter.get_output_details()[0][\"index\"]\n )()\n\n return style_bottleneck\n\n# Calculate style bottleneck for the preprocessed style image.\nstyle_bottleneck = run_style_predict(preprocessed_style_image)\nprint('Style Bottleneck Shape:', style_bottleneck.shape)",
"_____no_output_____"
]
],
[
[
"### Style transform",
"_____no_output_____"
]
],
[
[
"# Run style transform on preprocessed style image\ndef run_style_transform(style_bottleneck, preprocessed_content_image):\n # Load the model.\n interpreter = tf.lite.Interpreter(model_path=style_transform_path)\n\n # Set model input.\n input_details = interpreter.get_input_details()\n interpreter.resize_tensor_input(input_details[0][\"index\"],\n preprocessed_content_image.shape)\n interpreter.allocate_tensors()\n\n # Set model inputs.\n interpreter.set_tensor(input_details[0][\"index\"], preprocessed_content_image)\n interpreter.set_tensor(input_details[1][\"index\"], style_bottleneck)\n interpreter.invoke()\n\n # Transform content image.\n stylized_image = interpreter.tensor(\n interpreter.get_output_details()[0][\"index\"]\n )()\n\n return stylized_image\n\n# Stylize the content image using the style bottleneck.\nstylized_image = run_style_transform(style_bottleneck, preprocessed_content_image)\n\n# Visualize the output.\nimshow(stylized_image, 'Stylized Image')",
"_____no_output_____"
]
],
[
[
"### Style blending\n\nWe can blend the style of content image into the stylized output, which in turn making the output look more like the content image.",
"_____no_output_____"
]
],
[
[
"# Calculate style bottleneck of the content image.\nstyle_bottleneck_content = run_style_predict(\n preprocess_style_image(content_image)\n )",
"_____no_output_____"
],
[
"# Define content blending ratio between [0..1].\n# 0.0: 0% style extracts from content image.\n# 1.0: 100% style extracted from content image.\ncontent_blending_ratio = 0.5 #@param {type:\"slider\", min:0, max:1, step:0.01}\n\n# Blend the style bottleneck of style image and content image\nstyle_bottleneck_blended = content_blending_ratio * style_bottleneck_content \\\n + (1 - content_blending_ratio) * style_bottleneck\n\n# Stylize the content image using the style bottleneck.\nstylized_image_blended = run_style_transform(style_bottleneck_blended,\n preprocessed_content_image)\n\n# Visualize the output.\nimshow(stylized_image_blended, 'Blended Stylized Image')",
"_____no_output_____"
]
]
] | [
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code",
"markdown",
"code"
] | [
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown",
"markdown"
],
[
"code",
"code",
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown",
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code"
],
[
"markdown"
],
[
"code",
"code"
]
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.