[Saved] How we did it: End-to-end deep learning in ArcGIS

How we did it: End-to-end deep learning in ArcGIS

Oil and gas is a huge industry in the United States, and is currently experiencing a boom in the Permian Basin. This oil-rich region stretches from western Texas to eastern New Mexico. Each day, hundreds of new well pads appear across the landscape, making it difficult for regulators to keep up with. But unregistered well pads are both a safety hazard and a missed opportunity for revenue for agencies such as the Bureau of Land Management.

At the plenary session of this year’s Esri Developer Summit, we demonstrated an end-to-end deep learning workflow to find unregistered well pads, using ArcGIS Notebooks. This can help regulators monitor the progress of new drilling on their land as well as look for potential illegal drilling.

Well Pads detected using deep learning. The ones highlighted in blue are not currently listed in the permits database.

The full workflow, from exporting training data and training a deep learning model to detecting objects across a large landscape, can be done using the ArcGIS API for Python. This blog article, originally written as an ArcGIS Notebook, shows how we did this with the help of the arcgis.learn module.

Geospatial deep learning

The field of artificial intelligence (AI) has progressed rapidly in recent years, matching or in some cases, even surpassing human accuracy. Broadly speaking, AI is the ability of computers to perform a task that typically requires some level of human intelligence. Machine learning is one type of engine that makes this possible, and uses data driven algorithms to learn from data to give you the answers that you need. One type of machine learning that has emerged recently is deep learning. Deep learning refers to deep neural networks, that are inspired from and loosely resemble the human brain.

The arcgis.learn module includes tools that support machine learning and deep learning workflows with geospatial data. This blog post focuses on deep learning with satellite imagery.

Applying Computer Vision to geospatial imagery

One area of AI where deep learning has done exceedingly well is computer vision, i.e. the ability for computers to ‘see’. This is particularly useful for GIS, as satellite, aerial and drone imagery is being produced at a rate that makes it impossible to analyse and derive insight from through traditional means. Object detection and pixel classification are among the most important computer vision tasks and are particularly useful for spatial analysis.

  • Object Detection involves finding objects within an image as well as their location in terms of bounding boxes. Finding what is in satellite, aerial or drone imagery, and where, and plotting it on a map can be used for infrastructure mapping, anomaly detection and feature extraction.
  • Pixel Classification, also referred to as image segmentation, involves classifying each pixel of an image as belonging to a particular class. In GIS, segmentation can be used for Land Cover Classification or for extracting roads or buildings from satellite imagery.

ArcGIS has tools to help with every step of the deep learning workflow including data preparation and exploratory data analysis, training deep learning models, deploying them for inferencing and finally disseminating results using web layers and maps and driving field activity.

ArcGIS Pro includes tools for labeling features and exporting training data for deep learning workflows and has being enhanced for deploying trained models for feature extraction or classification. ArcGIS Image Server in the ArcGIS Enterprise 10.7 release has similar capabilities and allow deploying deep learning models at scale by leveraging distributed computing. ArcGIS Notebooks provide one-click access to pre-configured Jupyter Notebooks along with the necessary deep learning libraries and a gallery of starter notebooks that show how deep learning models can be easily trained and deployed.

The arcgis.learn module

The arcgis.learn module in ArcGIS API for Python enable GIS analysts and data scientists to easily adopt and apply deep learning in their workflows. It enables training state-of-the-art deep learning models with a simple, intuitive API. By adopting the latest research in deep learning, it allows for much faster training and removes guesswork in the deep learning process. It integrates seamlessly with the ArcGIS platform by consuming the exported training samples directly, and the models that it creates can be used directly for inferencing (object detection and pixel classification) in ArcGIS Pro and Image Server.

This module includes methods and classes for:

  • Exporting Training Data
  • Data Preparation
  • Model Training
  • Model Management
  • Inference


Data preparation, augmentation and model training workflows using arcgis.learn have a dependency on PyTorch and deep learning libraries.

If you are using ArcGIS Notebook Server, the dependencies are already installed.

In the ArcGIS Pro 2.3 Python environment, the dependencies need to be installed using these commands:

conda install -c conda-forge spacy

conda install -c pytorch pytorch=1.0.0 torchvision

conda install -c fastai fastai=1.0.39

conda install -c arcgis arcgis=1.6.0 –no-pin

Otherwise, in a new conda environment, issue the following commands:

conda install -c fastai -c pytorch -c esri fastai=1.0.39 pytorch=1.0.0 torchvision arcgis=1.6.0

Object Detection with arcgis.learn

Deep learning models ‘learn’ by looking at several examples of imagery and the expected outputs. In the case of object detection, this requires imagery as well as known (or labelled) locations of objects that the model can learn from. With the ArcGIS platform, these datasets are represented as layers, and are available in our GIS.

In the workflow below, we will be training a model to identify well pads from Sentinel-2 imagery. Sentinel-2 is an Earth observation mission developed by ESA as part of the Copernicus Programme to perform terrestrial observations in support of services such as forest monitoring, land cover change detection, and natural disaster management.

In this analysis, data downloaded from has been used for creating hosted image service in our GIS. The code below connects to our GIS and accesses the known well pad locations and the Sentinel imagery:

from arcgis.gis import GIS

from arcgis.raster.functions import apply

from arcgis.learn import export_training_data

gis = GIS(“home”)

# layers we need – The input to generate training samples and the imagery

well_pads = gis.content.get(‘ae6f1c62027c42b8a88c4cf5deb86bbf’) # Well pads layer


# Sentinel-2 imagery published to portal

sentinel_item = gis.content.get(“15c1069f84eb40ff90940c0299f31abc”)


Exporting Training Samples

The export_training_data() method generates training samples for training deep learning models, given the input imagery, along with labeled vector data or classified images. Deep learning training samples are small subimages, called image chips, and contain the feature or class of interest. This tool creates folders containing image chips for training the model, labels and metadata files and stores them in the raster store of your enterprise GIS. The image chips are often small, such as 256 pixel rows by 256 pixel columns, unless the training sample size is larger. These training samples support model training workflows using the arcgis.learn package as well as by third-party deep learning libraries, such as TensorFlow or PyTorch.

The object detection models in arcgis.learn accept training samples in the PASCAL_VOC_rectangles (Pattern Analysis, Statistical Modeling and Computational Learning, Visual Object Classes) format. The PASCAL VOC dataset is a standardized image dataset for object class recognition. The label files are XML files and contain information about image name, class value, and bounding boxes.

The models in arcgis.learn take advantage of pretrained models, that have been trained on large image collections, such as ImageNet, and fine tune them on satellite imagery. Pretrained models like these are excellent feature extractors and can be fine-tuned relatively easily on another task or different imagery without needing as much data. However, since the photographs that these models have been trained on contain only 3 channels (Red, Green Blue), we cannot take advantage of all the bands available in multispectral imagery, and need to pick 3.

The extract_bands() method can be used to specify which 3 bands should be extracted for fine tuning the models. In our analysis, we will be using the pre-configured ‘Natural Color with Dynamic Rage Adjustment(DRA)’ raster function:

sentinel_data = apply(sentinel_item.layers[0], ‘Natural Color with DRA’, astype=’U8′)

For better training, image chips should be exported with a larger size than that used for training the models. This allowsarcgis.learn to perform random center cropping as part of it’s default data augmentation and makes the model see a different sub-area of each chip when training leading to better generalization and avoid overfitting to the training data. By default, a chip size of 448 x 448 pixels works well, but this can be adjusted based on the amount of context you wish to provide to the model, as well as the amount of GPU memory available.

Here, we are exporting the training data for our model in the well_pads folder:

export_training_data(sentinel_data, well_pads, “PNG”,

                            {“x”:448,”y”:448}, {“x”:224,”y”:224},

                            “PASCAL_VOC_rectangles”, 75,


Data Preparation

Once the training samples have been exported, they need to be fed into the model for training. Data preparation can be a time consuming process that involves collating and massaging the training chips and labels into the specific format needed by each deep learning model.

Typical data processing piplelines involve splitting the data into training and validation sets, applying various data augmentation techniques, creating the necessary data structures for loading data into the model, setting the appropriate batch size and so on.arcgis.learn automates all these time consuming tasks and the prepare_data() method can directly read the training samples exported by ArcGIS. The prepare_data() method inspects the format of the training samples exported by export_training_data tool in ArcGIS Pro or Image Server (whether for object detection or pixel classification) and constructs the appropriate fast.aiDataBunch from it. This DataBunch consists of training and validation DataLoaders with the specified transformations for data augmentations, chip size, batch size, and split percentage for train-validation split.

By default, prepare_data uses a default set of transforms for data augmentation, that work well for satellite imagery. These transforms randomly rotate, scale and flip the images so the model sees a different image each time. This helps the model generalize better and not just ‘remember’ or overfit to the specific images in the training set. Alternatively, users can compose their own transforms transforms for the specific data augmentations they wish to perform.

from arcgis.learn import prepare_data

data = prepare_data(‘/arcgis/directories/rasterstore/well_pads’,

                   {0: ‘   Pad’})

The show_batch() method can be used to visualize the exported training samples, along with labels, after data augmentation transformations have been applied.


Model Training

arcgis.learn includes support for training deep learning models for object detection. Support for training pixel classification model is coming in the next release.

The models in arcgis.learn are based upon pretrained Convolutional Neural Networks (CNNs, or in short, convnets) that have been trained on millions of common images such as those in the ImageNet dataset for image classification tasks. These CNNs (such as Resnet, VGG, Inception, etc.) can classify what’s in an image by basing their decision on features that they learn to identify in those images. In particular, they use a hierarchy of layers, with the earlier layers learning to identify simple features like edges and blobs, middle layers combining these primitive features to identify corners and object parts and the later layers combining the inputs from these in unique ways to grasp what the whole image is about (i.e. the semantic meaning). The final layer in a typical convnet is a ‘fully connected’ layer that looks at all the extracted semantic meaning in the form of feature maps across the whole image and essentially does a weighted sum of these to come up with a probability of each object class (whether its an image of a cat or a dog, or whatever).

A convnet trained on a huge corpus of images such as ImageNet is thus considered as a ready-to-use feature extractor. We could replace the last few layers of these convnets and substitute it with something else that uses those features for other useful tasks, such as object detection and pixel classification.

The arcgis.learn module is based on PyTorch and and enables fine-tuning of pretrained torchvision models on satellite imagery. Pretrained models like these are excellent feature extractors and can be fine-tuned relatively easily on another task or different imagery without needing as much data. The arcgis.learn models leverages’s learning rate finder and one-cycle learning, and allows for much faster training and removes guesswork in the deep learning process.

arcgis.learn includes the SingleShotDetector model (based on MOOC Version2 Lesson 9) for object detection tasks. A pretrained convnet, like ResNet, acts as the ‘backbone’ upon which the SingleShotDetectormodel is based, or as the ‘encoder’ part of the upcomingUnetClassifier.

Object Detection using SingleShotDetector

Once we have a good image classifier, a simple way to detect objects is to slide a ‘window’ across the image and classify whether the image in that window (cropped out region of the image) is of the desired type. However, this is terribly inefficient as we need to look for objects everywhere in the image, and at different scales, as the objects might be larger or smaller. This requires multiple passes of regions of the image through the image classifier which is computationally infeasible. Another class of object detection networks (like R-CNN and Fast(er) R-CNN) use a two stage approach — first to identify regions where objects are expected to be found and then running those region proposals through the convnet for classifying and creating bounding boxes around them.

The latest generation of object detection networks such as YOLO (You Only Look Once) and SSD (Single-Shot Detector) use a fully convolutional approach in which the network is able to find all objects within an image in one pass (hence ‘single-shot’ or ‘look once’) through the convnet.

“SSD: Single Shot MultiBox Detector”, 2015; arXiv:1512.02325.

Instead of using a region proposal networks to come up with candidate locations of prospective objects, the Single Shot MultiBox Detector (on which the SingleShotDetector is modeled) divides up the image using a grid with each grid cell responsible for predicting which object (if any) lies in it and where.

Backbone SSD uses a pre-trained image classification network as a feature extractor. This is typically a network like ResNet trained on ImageNet, from which the final fully connected layers to come up with the predicted class of an input image have been removed. We are thus left with a deep neural network that is able to extract semantic meaning from the input image while preserving the spatial structure of the image albeit at a lower resolution. For ResNet34 the backbone results in a 256 7×7 ‘feature maps’ of activations for each input image. Each of these 256 feature maps can be interpreted as a grid of 7×7 activations that fire up when a particular feature is detected in the image. In the SSD architecture, one or more convolutional layers are added to this backbone and the outputs are interpreted as the bounding boxes and classes of objects in the spatial location of the final layer’s activations.

Receptive Field Convolutional neural networks preserve the spatial structure of an image because of the way the convolution operation is applied. A learnable filter slides over the image from left to right and top to bottom and the activations represent how similar that part of the image is to the filter. Each activation in the output feature map is thus ‘looking at’ that region of the previous feature map (and ultimately the image because a deep CNN has multiple such convolutional layers). The part of the image that is ultimately responsible for an activation in a feature map is referred to as the ‘receptive field’ of that activation. Each activation in the output feature map has ‘seen’ that part of the image more than any other activation and is it natural to expect that activation to contain the most information needed to detect objects in its receptive field. This is the central premise of the SSD architecture.

As it’s possible for multiple objects to occupy a grid cell, and for the objects to have a different sizes or aspect ratios, each grid cell has several assigned anchor boxes (also known as prior boxes) — one for each possible object size and aspect ratio within that grid cell. SSD uses a matching phase while training, to match the appropriate anchor box with the bounding boxes of each ground truth object within an image. Essentially, the anchor box with the highest degree of overlap with an object is responsible for predicting that object’s class and its location. This property is used for training the network and for predicting the detected objects and their locations once the network has been trained.

Having a knowledge of the SingleShotDetector architecture and how the anchor boxes are specified using grid cells, aspect ratios and zoom levels allows one to design a suitable model for the object detection task at hand. If the objects you are detecting are all of roughly the same size, you can simplify the network architecture by using just one scale of the anchor boxes. A simpler network is easier to train. More powerful networks can detect multiple overlapping objects of varying sizes and aspect ratios, but need more data and computation for training.

Grid cells A simple way to detect multiple objects in an image is to divide the image using a grid and have each grid cell be responsible for detecting objects in that region of the image. Detecting objects simply means predicting the class(type) and location of an object within that region. If no object is present, we consider it as the background class and the location is ignored.

In the SSD architecture, we add additional convolutional layers to the backbone network and architect the additional layers in such a manner that the spatial size of the final layer is the same as the size of the grid we are using. The depth of the final feature map is used to predict the class of the object within the grid cell and it’s bounding box. This allows SSD to be a fully convolutional network that is fast and efficient, while taking advantage of the receptive field of each grid cell to detect objects within that grid cell.

For instance, we could use a 4×4 grid to detect objects in an image, when we see that their size is such that approximately 16 of them could occupy an image chip (4 on a side).

Such an SSD architecture can be created using:

ssd = SingleShotDetector(data, grids=[4], zooms=[1.0], ratios=[[1.0, 1.0]])

The grids parameter specifies the size of the grid cell, in this case 4×4. Additionally, we are specifying a zoom level of 1.0 and aspect ratio of 1.0:1.0. What this essentially means is that the network will create an anchor box (or prior box, as its known in other places) for each grid cell, which is the same size as the grid cell (zoom level of 1.0) and is square in shape with an aspect ratio of 1.0:1.0 The output activations along the depth of the final feature map are used to shift and scale this anchor box (within a reasonable limit) so it can approach the actual bounding box of the object even if it doesn’t exactly line up with the anchor box.

We might be interested in several layers or hierarchies of grid cells. For example, we could use a 4×4 grid to find smaller objects, a 2×2 grid to find mid sized objects and a 1×1 grid to find objects that cover the entire image. That can be done by specifying [4, 2, 1] as the grids parameter.

Zoom levels/scales

Cars and Pools have different scales

It is not necessary for the anchor boxes to have the same size as the grid cell. We might be interested in finding smaller or larger objects within a grid cell. The zooms parameter is used to specify how much the anchor boxes need to be scaled up or down with respect to each grid cell.

Aspect ratios

Not all objects are square in shape. Some are longer and some are wider, by varying degrees. The SSD architecture allows pre-defined aspect ratios of the anchor boxes to account for this. The ratios parameter can be used to specify the different aspect ratios of the anchor boxes associates with each grid cell at each zoom/scale level.

Having multiple anchor boxes per grid cell with different aspect ratios and at different scales, while also allowing for multiple hierarchies of grid cells results in a profusion of potential anchor boxes that are candidates for matching the ground truth while training, and for prediction.

Creating SingleShotDetector Model

Since the image chips visualized in the section above indicate that most well pads are roughly of the same size and square in shape, we can keep an aspect ratio of 1:1 and zoom (scale) of 1. This will help simplify the model and make it easier to train. Also, since the size of well pads in the image chips is such that approximately nine could fit side by side, we can keep a grid size of 9.

We then create a Single Shot Detector with a specified grid size, zoom scale and aspect ratio:

from arcgis.learn import SingleShotDetector

ssd = SingleShotDetector(data, grids=[9], zooms=[1.0], ratios=[[1.0, 1.0]])

Finding the optimum learning rate

Once the appropriate model has been constructed, it needs to be trained over several epochs, or training passes over the training data. This process involves setting the optimum learning rate. Picking a very small learning rate leads to slow training of the model, while picking one that it too high can prevent the model from converging and ‘overshoot’ the minima, where the loss (or error rate) is lowest. arcgis.learn includes’s learning rate finder, accessible through the model’s lr_find() method, that helps in picking the optimum learning rate, without needing to experiment with several learning rates and picking from among them.


The learning rate is specified using two numbers – a lower rate for fine tuning the earlier layers of the pretrained backbone, and the higher rate for training the newly added layers for the task at hand. The higher learning rate can be deduced by inspecting the learning rate graph and picking the highest learning rate (on the x axis) where the loss is still going down (while still being lower than the point from where it shoots up). The lower learning rate is usually a fraction (one tenth works well) of the higher rate but can be adjusted depending upon how different the imagery is from natural images on which the backbone network is trained.

In the chart above we find that the loss is going down steeply at 2e-02 (0.02) and we pick that as the higher learning rate. The lower learning rate is approximately one tenth of that. We choose 0.001 to be more careful not to disturb the weights of the pretrained backbone by too much. This is why we are picking a learning rate of slice(0.001, 0.02) to train the model in the next section.

Training the model

Training the model is an iterative process. We can train the model using its fit() method till the validation loss (or error rate) continues to go down with each epoch (or training pass over the data). This is indicative of the model learning the task., slice(0.001, 0.02))

As each epoch progresses, the loss (error rate, that we are trying to minimize) for the training data and the validation set are reported. In the table above we can see the losses going down for both the training and validation datasets, indicating that the model is learning to recognize the well pads. We continue training the model for several iterations like this till we observe the validation loss starting to go up. That indicates that the model is starting to overfit to the training data, and is not generalizing well enough for the validation data. When that happens, we can try reducing the learning rate, adding more data (or data augmentations), increase regularization by increasing the dropoutparameter in the SingleShotDetector model, or reduce the model complexity.

Unfreezing the backbone and fine-tuning

By default, the earlier layers of the model (i.e. the backbone or encoder) are frozen and their weights are not updated when the model is being trained. This allows the model to take advantage of the (ImageNet) pretrained weights for the backbone, and only the ‘head’ of the network is trained initially. Once the later layers have been sufficiently trained, it helps to improve model performance and accuracy to unfreeze() the earlier layers and allow their weights to be fine-tuned to the nuances of the particular satellite imagery compared to the photos of everyday objects (from ImageNet) that the backbone was trained on. The learning rate finder can be used to identify the optimum learning rate between the different training phases .

Visualizing results

The results of how well the model has learnt can be visually observed using the model’s show_results() method. The ground truth is shown in the left column and the corresponding predictions from the model on the right. As we can see below, the model has learnt to detect well pads fairly well. In some cases, it is even able to detect the well pads that are missing in the ground truth data (due to inaccuracies in labeling or the records).

ssd.show_results(rows=25, thresh=0.05)

Saving trained model

Once you are satisfied with the model, you can save it using the save()method. This creates an Esri Model Definition (EMD file) that can be used for inferencing in ArcGIS Pro as well as a Deep Learning Package (DLPK zip) that can be deployed to ArcGIS Enterprise for distributed inferencing across a large geographical area. Saved models can also be loaded back using the load()method, for futher fine tuning.‘WellPadDetector’)

> Created model files at /arcgis/directories/rasterstore/well_pads/models/WellPadDetector

Deploying model

Once a model has been trained, it can be added to ArcGIS Enterprise as a deep learning package.

trained_model = ‘/arcgis/directories/rasterstore/well_pads/models/WellPadDetector/’

model_package = gis.content.add(item_properties={

           “type”:”Deep Learning Package”,

           “typeKeywords”:”Deep Learning, Raster”,

           “title”:”Well Pad Detection Model”,


           “overwrite”:’True’}, data=trained_model)


Model lifecycle management

The arcgis.learn module includes the install_model() method to install the uploaded model package (*.dlpk) to the raster analytics server.

Optionally after inferencing the necessary information from the imagery using the model, the model can be uninstalled usinguninstall_model(). The deployed models on an Image Server can be queried using the list_models()method.

The uploaded model package is installed automatically on first use as well. We can query the settings of the deep learning model using the query_info().

from arcgis.learn import Model

detect_objects_model = Model(model_package)


Detecting Objects

The detect_objects() function can be used to generate feature layers that contains bounding box around the detected objects in the imagery data using the specified deep learning model.

Note that the deep learning library dependencies needs to be installed separately, in addition on the image server.

For arcgis.learn models, the following sequence of commands in ArcGIS Image Server’s Pro Python environment install the necessary dependencies:

conda install -c conda-forge spacy

conda install -c pytorch pytorch=1.0.0 torchvision

conda install -c fastai fastai=1.0.39

conda install -c arcgis arcgis=1.6.0 –no-pin

We specify the geographical extent and imagery cell size for feature extraction, and whether to use the GPU or CPU in the contextparameter. Each detection has an associated score, that indicates how confident the model is about that prediction. We can set a score threshold to filter out false detections. In this case, we found that we can lower the score threshold to 0.05 and catch more detections without having too many false detections. A non max suppression(nms_overlap) parameter can be specified to weed out duplicate overlapping detections of the same object.

context = {‘cellSize’: 10,


          ‘extent’:{‘xmin’: -11587791.393960,

                    ‘ymin’: 3767970.198031,

                    ‘xmax’: -11454320.817016,

                    ‘ymax’: 3875304.476397, ‘spatialReference’: {‘latestWkid’: 3857, ‘wkid’: 102100}}}

params = {‘padding’:’0′, ‘threshold’:’0.05′, ‘nms_overlap’:’0.1′, ‘batch_size’:’64’}

Finally, the code below shows how we can use distributed raster analytics to automate object detection across a large geographical area and create a feature layer of well pad detections.

from arcgis.learn import detect_objects

detected_pads = detect_objects(input_raster=sentinel_data,







Visualizing detection layer

We can visualize the results using the map widget, right within the notebook.

web_map =“title: Well Pad Detection AND owner:portaladmin”,item_type=”Web Map”)[0]

map_widget =

map_widget.extent = {‘spatialReference’: {‘latestWkid’: 3857, ‘wkid’: 102100},

‘xmin’: -11397184.938845266,

‘ymin’: 3761693.7641860787,

‘xmax’: -11388891.521276105,

‘ymax’: 3764082.4213200537}

map_widget.zoom = 15


We could take these results, share them as maps and layers, do further analysis to find which well pads are missing in the database, where the hotspots of new drilling activity are, and how they are changing over time. With Workforce for ArcGIS, we can create assignments for mobile workers, such as inspectors and drive field activity. In conclusion, ArcGIS has end-to-end support for deep learning — from hosting the data, to exporting training samples and training a deep learning model, to detecting objects across a large region and driving field activity.

[Saved] Parking Lot Vehicle Detection Using Deep Learning

The Era of Drones

Although the idea of vehicle detection is not a groundbreaking one and has been around since the emergence of video cameras and embedded sensors, these methods were often marred by high capital and maintenance costs and a high complexity from having to integrate multiple data sources, each with a limited band of inputs. The prevalence of drones in the commercial market in recent years on the other hand, has brought about a new era of state-of-the-art aerial photogrammetry and a drastic reduction in the cost of obtaining aerial data. With this sudden increase in information, and by combining machine learning with GIS technologies, we are now capable of performing new and insightful analyses on issues of interest.

Existent business problems which stand to benefit from this include customer flow analyses and demographic modelling. This is particularly useful for those in the retail sector looking to monitor peak business hours by counting the number of parked vehicles at a given time and also extrapolate useful customer information (such as income, marital status, household size and even political inclination) by classifying the types of vehicles they own.

So, can we solve these problems using AI and GIS? The answer is yes, and a good starting point would be to come up with a workflow that tallies the number of cars per unit time as well as infer the vehicle type for every positive detection. In this article, I aim to give a comprehensive overview of a such a workflow — from data acquisition and processing using Drone2Map to performing data inferencing using TensorFlow and ArcGIS Pro, and finally to creating actionable BI visualizations using The Operations Dashboard in ArcGIS Online (AGOL).

Complete vehicle detection/classification workflow, all training was carried out on the GeoAI Data Science Virtual Machine (DSVM) on Azure, which offers a ready-to-use environment for training machine learning models along with ArcGIS Pro pre-installed.

Data Collection & Exploratory Analysis using Drone2Map

To obtain some sample data, we flew a drone over a busy parking lot here at our office in Redlands, California and obtained a series of geo-tagged tiff files with geolocation corroborated by 5 ground control points (GCPs) to ensure the result would be accurate enough to identify the correct parking space for each vehicle. These images were captured along a “lawn mower” flight path with an overlap of 70% along flight lines and at least 60% between flight lines. The reason we do this is to facilitate the generation of true orthomosaics. Traditional orthos (or “frame” orthos) suffer from what is known as the “layover effect”, where tall structures such as trees or buildings seemingly “lean” toward or away from the observer as a consequence of stitching together disparate frames that do not capture objects at a true nadir perspective. This effect worsens for objects that are at the edges of a drone’s field of view.

Using Drone2Map, we can take these individual frames and resolve for an object’s true ortho by finding common views between a frame and its 8 adjacent frames in a point cloud and then keeping the views that have a high degree of overlap. The resultant orthomosaic is not only a true ortho, but one that does not reveal seamlines between images typical of frame orthos.

Of course, all of this is automated, and the actual image processing step is simple: Create a 2D mapping project in Drone2Map, pull in your data, add ground control points as needed and then hit start to generate a true orthomosaic.

2D orthomosaic visualized in Drone2Map

From this, we obtain 3 classes of output products: A 2D orthomosaic of our parking lot, a digital surface model (DSM) layer and a digital terrain model (DTM) layer. An initial thought was to simply pass the DSM to a detection network to produce bounding boxes on distinctly “car-like” protrusions. However, on closer inspection of the dataset we identified some potential issues with this approach: in this particular parking lot, the coverage of foliage was so extensive as to affect the detection of certain cars partially or completely hidden by overhanging branches and leaves.

DSM view with partially obstructed parking spaces

The overhanging vegetation affected both the DSM and orthomosaic, but since the edge of each image includes oblique view angles at the image edges, some images were able to view partially or completely underneath the tree canopy. ArcGIS also enables each image from the drone to be orthorectified. Following photogrammetric processing in Drone2Map, each image could be analyzed in its proper geospatial placement, providing multiples views of each parking space.

Orthomosaic that offers a better view of partially covered vehicles

Processing of these oblique views was beyond the scope of this initial project, but will be the subject of future testing. In addition, parts of the canopy depicted by the orthomosaic are not fully opaque, and the RGB bands may also provide additional channels that would allow correct subdivision of vehicles into categories such as trucks, sedans and SUVs. From a data collection standpoint, it is also much easier to collect pure ortho imagery than outfitting drones with LIDAR sensors for DSM/DTM detection.

Simple Approach: Building a classification model using InceptionV3

Our first solution for tackling this problem was an obvious one: Simply overlay a polygon layer from a mapped parking lot on top of the orthomosaic raster and clip out cars using the Split Raster geoprocessing tool to get our prediction set. This was very easily done.

Then comes the question of which classification model to apply atop which finetuning set. A simple off-the-shelf model that’s available from both TensorFlow Slim and TensorFlow Hub is InceptionV3. Based off the original InceptionNet (Szegedy et al.), this third revision bears much resemblance in terms of core structure to the original with similar component modules. However, it has the addition of factorization methods to reduce the representational bottleneck as well as label smoothing and batch norm operations on the auxiliary classifiers to increase regularization.

As with most TensorFlow Hub models, there is no need to train from scratch when we can apply transfer learning; Luckily, InceptionV3 was pretrained on ImageNet.

As for the finetuning set, The Cars Overhead with Context (COWC) dataset from LLNL was an easy pick for its richly annotated set of 32,716 vehicles as well as hard negative examples (boats, commercial vehicles etc.). Although the dataset doesn’t plug straight into the classification network, the only preprocessing work here involves reading through the list of the annotated text files and cropping the associated jpegs with either OpenCV or ImageMagick. (N.B. the COWC dataset has 4 class labels: Sedan, Pickup, Others and Unknown. With an additional background class that makes 5 classes. I had to play around with class balancing to ensure each class was sufficiently represented, and also mine some samples for background classes which weren’t provided in COWC).

The COWC dataset for the pickup class and sedan class

These images have been extracted from the original COWC format which is comprised of large 22000×22000 images with bounding box information contained in ancillary .txt files. One thing to note is that the original bounding box coordinates tended to crop off large sections of the vehicles in question, which ultimately lead to worse overall performance in identifying the pickup class. Therefore these images have all been cropped using larger 34×34 bounding boxes.

Classification loss after 30k iterations, note the large variation in performance within a mini-batch. The orange line represents training accuracy and the blue line represents validation accuracy.

By looking at the COWC dataset we can immediately tell that the resolution of the dataset is not ideal. Early training results have shown that the classification network performed exceedingly well in binary classification tasks of identifying occupied/unoccupied spaces, but performed worse in distinguishing between vehicle classes. Part of the reason for this is also due to the fact that the pickup class was severely underrepresented. Testing proved that undersampling the sedan/other/background classes yielded the best validation accuracy (as opposed to oversampling the pickup class).

Once the model was sufficiently trained (on a good GPU this takes a couple hours — for me it was a Tesla K80 on the GeoAI VM for about 1.5 hours at a training accuracy of 0.85 and a validation accuracy of 0.84), we can proceed to apply our previously extracted prediction set to the model.

Output these results into a .csv file (it might be useful to apply some smart naming conventions here to ensure your data items match the OBJECTIDs of each polygon in the parking space feature layer. From here, simply combine the two layers using Add Join and voilà, you have a polygon layer that associates a class probability with each parking space based on an aerial image you took.

Thus far, we have only created some rich geotagged layers that are not yet informative nor intuitive enough give any kind of analytical insight. This is where ArcGIS Online offers us a path forward: we export both the orthomosaic as well as the feature layer to our ArcGIS Online Portal, then optionally in the MapViewer, modify the symbology of our polygon layer to be attribute-driven.

Sharing a feature layer as a web layer
Editing the feature class in MapViewer allows you to modify the default symbology. In my case, blue = sedan, red = pickup trucks, while transparency is determined by classification confidence.

You can then import individual maps and visualize the results interactively on the Operations Dashboard:

The Ops Dashboard reveals insight at a glance

We scheduled two drone flights over the same parking lot at different times of the day. To complement this data, we have also generated some mock input to illustrate occupancy info on an hourly basis that simulates customer flow within a typical work day. The Hour Selector cycles through parking patterns over every time segment. To suit your use case, you may also decide to deploy a drone every few weeks or every few months. The Average Occupancy Heatmap is a visual representation of “hot spots” wherein vehicles aggregate. If you like it is also possible to generate a “Turnover Heatmap” that maps regions in which vehicles are likely to park for longer/shorter periods. Both of these views are potentially useful for understanding demographic behavior when crossed-referenced with vehicle types or to detect favorite stores & customer stay-times at shopping venues.

The two useful vehicle categories from COWC: sedans and pickups, are shown in the Vehicle Types visual element, each color coded and also with a transparency level linked to its classification confidence. Finally, pure vehicle counting/detection is presented in the Current Vehicle Classification Analysis view with a gauge to show the current occupancy.

Shortcomings of a classification-only model

Our blind assumption for a classification-only approach is that all cars fit neatly inside each parking space polygon (failing to take into account bad drivers, double-parkers or your regular F150s so easily cropped off by the sensibly-sized parking spaces). Of course, there are other use cases for vehicle detection for which a predefined polygon layer is simply impossible to draw (think roadside parking or parking lots for which there are no guidelines). These coupled with the fact that a simple classification network is simply not “smart enough” prompted us to think of another approach to this problem.

Better Approach: Building a detection model using Faster-RCNN

The fundamental idea behind a Faster-RCNN network is that it does two things at once: It detects the bounding boxes of objects of interest using a Region Proposal Network (RPN), and performs classification on those detections using a base classifier after region of interest pooling (ROI).

Faster R-CNN architecture, click here for a more a more comprehensive article

Like our previous attempt, we used COWC for fine-tuning. This time, there is no need to extract individual vehicles for training. To visualize what the dataset looks like, you can test out the following snippet by replacing the (x,y), width and height values in the patches.Rectangle() method with whatever value is shown in an image’s corresponding .txt file.

Snippet to visualize COWC bounding box annotations
Output of a COWC patch

I also had to manually convert these images into Pascal VOC format to be consumed by the Faster R-CNN model. Unlike the classification model, training this model took roughly 24 hours on the K80. This is because in Faster R-CNN, anchor generation within the RPN forms a bottleneck (potentially generating up to 6000 region proposals per image). Other detection models such as SSD or YOLO (at least the first generation) ameliorate the speed issue at the cost of lower mAP scores. However, seeing as we are not concerned with near real-time detection, it suffices to use Faster R-CNN to produce a good output at reasonable speeds (~7 seconds or so on the CPU for each image tile of size of 600×600 which is rescaled from the original 5000×5000 px). Again, Faster R-CNN is provided in the TensorFlow models library. There you can also find some default configuration files for the base classifier you have chosen (ResNet101 pretrained on the MS COCO dataset in my case). There are in fact a whole slew of pretrained base models from TensorFlow’s detection model zoo you can choose for yourself, each with their own speed/mAP trade-off.

This is part of the configuration file I used, note the height and width values that match the COWC “patch_size”, or size of each input image tile. This can be configured in the script from COWC’s Github page. Additionally you can choose to base your classification model on something other than ResNet101. Depending on the size of your detection it may also be prudent to adjust the scales of your anchor for faster convergence, although I find it much more effective to re-tile your inputs if each object ends up comprising less than 4% of your input size.

Faster R-CNN loss, note the fast converging RPN loss meaning it is much easier for the network to place a bounding box than it is for it to determine the class of vehicle in an existing bounding box.

You can of course write your own evaluation script to visualize the trained model. There is in fact a very good template on TensorFlow’s Github page. I made some modifications to the following snippet to also allow you to adjust the detection threshold and the number of boxes to draw which I find very useful in visually understanding the performance of your model early on in the training process:

Preliminary evaluation result which shows an abundance of the “Other” category. You can reduce this with a simple thresholding function either in script or in ArcGIS Pro.

Alternatively, if you wish for a more straightforward approach to performing inferencing, the upcoming ArcGIS Pro 2.3 offers a convenient geoprocessing tool “Detect Objects Using Deep Learning” to perform evaluation on any input raster by passing it a trained model in the form of a frozen inference graph protobuf defined inside a model description JSON file. As well as several evaluation hyperparameters such as padding and detection threshold. Hit run and you get a new feature layer of bounding boxes in return.

Applying the Detect Objects Using Deep Learning geoprocessing tool for inferencing

Similar to the classification approach, we can visualize these layers much more effectively by exporting them to ArcGIS Online and viewing them in the Operations Dashboard.

Vehicle detection dashboard, note the successful detection of vehicles that are not parked within designated parking spaces. The morning/afternoon detections are also shown to reveal changes in parking behavior.

All the views from the classification dashboard can also be represented here with the same analyses drawn, but now vehicles parked outside of predesignated spaces (including vehicles in motion) are all detected using Faster R-CNN.

Closing thoughts and future work

This article serves as an exploratory glimpse into machine learning-driven GIS for vehicle detection, and of how important business decisions can be informed from start to finish by leveraging the powerful Esri ecosystem to create a complete BI workflow.

The models described above can of course be taken a couple steps further, by training on an input set with richer annotations or cross-referencing the COWC dataset with datasets that tie together vehicle types with income and other demographic info to produce even more powerful analyses, reveal subtler patterns and yield finer customer segmentations. Likewise, these models apply to aerial detection of all kinds (crops, utility poles, animals, forest fires, ships), as long as you have access to a decent GPU and a fine-tuning dataset.

Another potential expansion to this pipeline would be to introduce oblique imagery into the mix in a manner similar to what was done in Esri’s Oblique Viewer App that allows for multiple oblique views to be attached to the same ortho frame. For vehicle detection this effectively increases the number of images from which we can extract high fidelity data and also gives an unobstructed view of cars hidden under tree canopies.

Hopefully this has been an interesting read, please give us a clap and share this post if you enjoyed it, and let us know in the comments what other insights can be drawn from these data and whether you think there’s a better approach to be considered!

This effort was done as part of the Esri GeoAI team. For other cool GISxML projects, check out the GeoAI Medium page here. Feel free to contact Omar Maherfor internship or full time opportunities! ([email protected])


[Saved] Integrating Deep Learning with GIS

Integrating Deep Learning with GIS

The field of Artificial Intelligence has made rapid progress in recent years, matching or in some cases, even surpassing human accuracy at tasks such as computer vision, natural language processing and machine translation. The intersection of artificial intelligence (AI) and GIS is creating massive opportunities that weren’t possible before. AI, machine learning and deep learning are helping us make a better world by helping increase crop yield through precision agriculture, to fighting crime by deploying predictive policing models, to predicting when the next big storm will hit and being better equipped to handle it.

Broadly speaking, AI is the ability of computers to perform a task that typically requires some level of human intelligence. Machine learning is one type of engine that makes this possible. It uses data driven algorithms to learn from data to give you the answers that you need. One type of machine learning that has emerged in recent years is deep learning and it refers to deep neural networks, that are inspired from and loosely resemble the human brain.

Machine Learning in ArcGIS

Machine learning has been a core component of spatial analysis in GIS. These tools and algorithms have been applied to geoprocessing tools to solve problems in three broad categories. With classification you can use support vector machine algorithms to create land cover classification layers. Another example is clustering that lets you process large quantities of input point data, identify the meaningful clusters within them, and separate them from the sparse noise. Prediction algorithms such as geographically weighted regression allows you to use geography to calibrate the factors that help you predict. These methods work well in several areas and their results are interpretable, but they need experts to identify or feed in those factors (or features) that affect the outcome that we’re trying to predict.

The rise of Deep Learning

Wouldn’t it be great if the machine figured out what those factors/features should be just by looking at the data? That’s where deep learning comes in. It’s inspired by and loosely resembles the human brain. In a deep neural network, there are neurons that respond to stimulus and they are connected with each other in layers. Neural networks have been around for decades but it has been a challenge to train them.

Integrating Deep Learning with ArcGIS — Webinar

So what’s changed now, and made them so successful at what they do? The advent of deep learning can be attributed to three primary developments in recent years — Data, Compute and Algorithmic improvements:

Data: We now have vast quantities of data thanks to the Internet, the sensors all around us and the numerous satellites that are imaging the whole world, every day.

Compute: We have powerful compute, thanks to cloud computing and GPUs that have become more powerful than ever, and gone down in price thanks to the gaming industry.

Algorithmic improvements: Finally, researchers have now cracked some of the most challenging aspects of training the deep neural networks through algorithmic improvements and network architectures.

Applying Computer Vision to geospatial analysis

One area of AI where deep learning has done exceedingly well is computer vision, or the ability for computers to see. This is particularly useful for GIS, as satellite, aerial and drone imagery is being produced at a rate that makes it impossible to analyse and derive insight from through traditional means.

The figure below shows some of the most important computer vision tasks or use cases and how they can be applied to GIS:

Fig 1. Important Computer Vision tasks applied to GIS

The simplest is Image Classification, in which the computer assigns a label, such as ‘cat’ or ‘dog’ to an image. This can be used in GIS to categorize geotagged photos. In the example above, we have an image that’s been classified as having a ‘dense crowd’ and such pedestrian activity classification can be used for pedestrian and traffic management planning during public events. An example of this was demonstrated at the Esri User Conference 2018 plenary session by Cobb County.

Traffic and pedestrian movement planning by Cobb County

Next, we have Object Detection in which the computer needs to find objects within an image as well as their location . This is a very important task in GIS — finding what is in satellite, aerial or drone imagery, and where, and plotting it on a map can be used for infrastructure mapping, anomaly detection and feature extraction.

Detected swimming pools within residential parcels

To read more about an example of using deep learning to detect and classify swimming pools, see this detailed blog post on Medium or the companion blog post at ArcGIS blogs.

Another important task in computer vision is Semantic Segmentation — in which we classify each pixel of an image as belonging to a particular class. For instance, in the image in Fig 1, the cat is in the yellow pixels, and the green pixels belong to the ground class and the sky is in blue. In GIS, semantic segmentation can be used for Land Cover Classification or to extract road networks from satellite imagery.

Land cover classification using deep learning

A nice early example of this work and its impact is the success the Chesapeake Conservancy has had in combining Esri’s GIS technology with Microsoft’s AI toolkit (CNTK) and cloud solutions to produce the first high-resolution land cover map of the Chesapeake watershed. This work is now also available as a tutorial that can be deployed on an Azure Geo AI Data Science virtual machine.

Another type of segmentation is Instance Segmentation, that you can think of as a more precise object detection in which the precise boundary of each object instance is marked out. This can be used for tasks like improving basemaps by adding building footprints or reconstructing 3D buildings from LiDAR data.

Building reconstructed in 3D using aerial LiDAR. The same building reconstructed in 3D from the masks digitized by human editors (left), and semantic segmentation masks produced by the Mask R-CNN (right)

Esri recently collaborated with NVIDIA to use deep learning and automate the manually-intensive process of creating complex 3D building models from aerial LiDAR data for Miami-Dade county. This task used this data to create segmentation masks for roof segments that were then used for 3D reconstruction of the buildings. See this detailed blog post on Medium on how this was done, or the companion post at ArcGIS Blogs.

Deep learning for mapping

An important application of deep learning for satellite imagery is to create digital maps by automatically extracting road networks and building footprints.

Imagine applying a trained deep learning model on a large geographic area and arriving at a map containing all the roads in the region, as well as the ability to create driving directions using this detected road network. This can be particularly useful for developing countries that do not have high quality digital maps or in areas where newer development have taken place.

Roads detected using deep learning and converted to geographical features

Good maps need more than just roads though — they need buildings. Recent developments of instance segmentation models like Mask-RCNN are particularly useful for building footprint segmentation, and can help create building footprints without any need of manual digitizing. However, these networks result in masks that look more like Antonio Gaudi masterpieces than regular buildings with straight edges and right angles. ArcGIS includes tools such as Regularize Building Footprints just for this.

Building footprints extracted out of satellite imagery and regularized using the Regularize Building Footprintstool in ArcGIS Pro.

Integrating ArcGIS with AI

ArcGIS has tools to help with every step of the data science workflow: from data preparation and exploratory data analysis, to training the model and to performing spatial analysis and finally disseminating results using web layers and maps and driving field activity. The Living Atlas provides access to a large collection of Esri curated and partner provided imagery that can be critical to a deep learning workflow.

Export Training Data for Deep Learning tool in ArcGIS Pro

ArcGIS Pro includes tools for helping with data preparation for deep learning workflows and has being enhanced for deploying trained models for feature extraction or classification. The ArcGIS Image Server in the ArcGIS Enterprise 10.7 release has similar capabilities and allow deploying deep learning models at scale by leveraging distributed computing. ArcGIS includes built in Python raster functions for object detection and classification workflows using CNTK, Keras, PyTorch, and TensorFlow. Additionally, you can write your own python raster function that use your deep learning library of choice or specific deep learning model/architecture. See this handy guide to get started!

Deep learning is a rapidly evolving field and using a code first approach allows data scientists to leverage cutting edge research while taking advantage of an industrial strength GIS. Python has emerged as the lingua franca of the deep learning world with popular libraries like Tensorflow, PyTorch and CNTK choosing it is their primary programming language. ArcGIS API for Python andArcPy are a natural fit for integrating with these deep learning libraries and allow your capabilities to expand.

The Road Ahead

The field of deep learning is nothing short of fascinating. This is a rapidly evolving field with state of the art results and new research papers coming out every week or month.

An example of superresolution — increasing the resolution of satellite imagery. Left — lower resolution, Right — increased resolution using deep learning

Some innovative uses of deep learning are for enhancing imagery such as by increasing zoom levels through the use of ‘Superresolution networks’. This technique can be used to increase clarity of satellite images and even go beyond the resolution of the sensors used.

Map art generated by applying the style of a painting to the satellite imagery of Eye of Sahara, a geographical feature in northern Africa.

Another innovative use of deep learning is in the field of ‘Creative AI’. Neural style transfer techniques can be used for generating ‘map art’ and can find practical use in GIS through cartographic style transfer.

Catrographic style transfer: Applying the style of Ortelius from the first world atlas in the 15th century(top right) to a map of New York city (bottom right) shows New York as a swamp(left) which it apparently was at that time!

Generative Adversarial Networks (GANs) are an active area of research and can be used for generating map tiles straight out of imagery.

While the examples above have focused on imagery and computer vision, deep learning can also be used equally well for processing large volumes of structured data such as observations from sensors, or attributes from a feature layer. Applications of such techniques to structured data include predicting the probability of accidents to sales forecasting, and natural language routing and geocoding.

Esri is investing heavily in these emerging technologies and has started a new R&D center in New Delhifocused on AI and Deep Learning on satellite imagery and location data. Check out to learn more about our work, see the open positions for data scientists, developers and engineers and apply online.
Công nghệ

[ML] Vọc phân loại ảnh với kỹ thuật Transfer Learning

Kỹ thuật Transfer Learning là gì thì mình xin dẫn lại lời của anh Duy Luân như sau:

Bình thường khi bạn train từ đầu các model (mô hình, mà mình thích dùng chữ model hơn) nhận diện hình ảnh, bạn sẽ cần rất nhiều sức mạnh từ máy tính. Nếu không có GPU khủng, nói chung là cấu hình mạnh thì sẽ mất rất nhiều thời gian. Chưa kể việc bạn phải viết từ đầu cũng là một thứ không chắc là hay trừ khi bạn cần phải tối ưu nó một cách cụ thể.
Thế nên người ta mới nghĩ tới Transfer Learning, nó là kĩ thuật giúp rút ngắn thời gian (và sức mạnh máy tính) cần thiết để train model bằng cách sử dụng một model nền có sẵn, tạm gọi là model được train gần hoàn chỉnh, sau đó train thêm chút xíu nữa bằng data của riêng bạn để có thể phân loại theo ý bạn muốn. Việc này giống như có ai đó đào móng, dựng cốt thép bê tông sẵn cho bạn rồi, bạn chỉ việc lên xây cái nhà theo ý thích của mình là được.
Bài hướng dẫn mình xem trên Google sử dụng ImageNet 122 làm nền. Đây là một database cực lớn về phân loại hình ảnh đã được Google phát triển một thời gian. Nó đã được train sẵn với 20 nghìn loại (category) hình ảnh khác nhau, chúng ta chỉ cần tận dụng nó thêm một bước nữa để áp category mà bạn muốn vào là được (thay vì chỉ dùng category do Google cung cấp).
Tất nhiên, việc bạn xài một giải pháp có sẵn sẽ không bao giờ có thể tốt như việc bạn từ làm từ đầu, model cũng thế. Nhưng không phải lúc nào bạn cũng cần tới mức phức tạp như vậy, đôi khi chỉ cần việc nó chạy là ngon lắm rồi, và tình huống của mình là như thế đấy. Độ chính xác tầm 70-80% là đã cực kì hiệu quả và giúp cho user của mình nhiều lắm rồi.
Kiểu transfer learning này cũng cho phép bạn train vài nghìn tấm ảnh bằng chính laptop của mình, ngay cả khi nó không có GPU rời. Cho nhu cầu cơ bản và để học, tìm hiểu thì quá tuyệt vời.

Bắt đầu thôi

Ở đây mình dùng Google Colab

Tài liệu

[Note] Các thuật toán unsupervised classification cho người mới bắt đầu + chút ứng dụng thực tế

Các thuật toán unsupervised classification cho người mới bắt đầu + chút ứng dụng thực tế


Mình đang có một số bài toán của công ty cần giải quyết cần research về vụ này, sẵn tiện viết ra để vừa nhớ vừa chia sẻ với các bạn luôn.


Bài toán của mình cũng đơn giản và khá tiêu biểu: một số đối tượng có các features A, B, C, D, E, F, cần classify các đối tượng này thành một số group nào đó để các đội vận hành xử lý tiếp. Bài toán thì không nói ra cụ thể được, anh em thông cảm  Nhưng điểm chung là các đối tượng này chưa từng được phân nhóm (clustering), tức là không có nhãn sẵn (label). Bạn phải đi tìm nhãn cho chúng.

Tiếp, mình chỉ viết mấy cái mình đã đụng, đã làm thôi nhé, còn mấy cái chưa xài thì không dám chém. Reference của mình là từ bài viết này: 112. 5 cái lận, mà mình viết 2 thôi.

K Mean

K Mean kiểu như là thuật toán phân loại nổi tiếng nhất, ở đâu cũng thấy, mấy môn học ML, data cơ bản thấy người ta cũng dạy nhiều. Bản thân team mình cũng dùng vài lần cho một số bài toán và thấy nó khá đúng, outcome đưa ra khá hài lòng. Bạn có thể xem giải thích chi tiết về K Mean và các nền tảng toán của nó 93, mình thì không hiểu nên thôi bỏ qua hihihi.

Về ứng dụng thực tế thì mình từng dùng K Mean thành công để phân loại khách hàng và phân loại nhóm đối tượng để bắn coupon cho hiệu quả (ví dụ: team marketing có 3 loại coupon cần gửi cho khách, bạn có thể dùng K Mean để tìm ra 3 nhóm này trong tập khách hàng của bạn dựa theo số đơn hàng, loại món, giờ mua hàng, tần suất mua hàng).

K Mean hoạt động theo cách cơ bản như sau: giả sử bạn có 1 loạt các điểm X, Y trong không gian.

Bước 1: Thuật toán sẽ tạo ra một số điểm bất kì trong không gian, ví dụ bạn muốn chia thành 3 nhóm thì k = 3. 3 điểm này gọi là centroids. Bước 2: Với mỗi điểm dữ liệu, nó sẽ tạm thời được phân vào một nhóm (cluster) dựa theo khoảng cách của điểm dữ liệu tới điểm k gần nhất. Bước 3: Với mỗi cluster này, tính mean của các điểm rồi gán điểm mean này là centroids mới Bước 4: Người ta sẽ lặp đi lặp lại bước 2 và 3 cho tới khi kết quả không còn thay đổi nhiều.

Bạn có thể xem được các bước này trong hình dưới.


Một cái hạn chế của K Mean là bạn buộc phải định nghĩa cho thuật toán biết bạn muốn tìm ra bao nhiêu nhóm. Bạn phải biết trước số này. Có một cách mình hay dùng để chọn số K, đó là thuật toán Elbow. Xem chi tiết ở đây, 61 còn bên dưới là một biểu đồ của mình để chọn K, thấy nó gấp khúc ngay K = 2 nên mình chọn phân làm 2 nhóm.


Code để implement K Mean thì dễ lắm. Cứ lấy một dataframe X với một loạt các features cần phân loại bỏ vào là xong.

# Number of clusters

kmeans = KMeans(n_clusters=2)

# Fitting the input data

kmeans =

# Getting the cluster labels

labels = kmeans.predict(X)

# Centroid values

centroids = kmeans.cluster_centers_

Với K Mean, nhớ cẩn thận dữ liệu NULL, dữ liệu sai, hoặc các nhóm quá lệch nhau. Có thể nó sẽ cho ra kết quả rất khác nhau đấy.

Mean Shifting

Thuật toán này cũng có thể giải những bài toán tương tự như trên với phân bố dữ liệu không có gì quá đặc biệt. Mình sẽ dùng Mean Shifting (MS) khi K Mean cho ra kết quả không phù hợp hoặc có gì đó lạ lạ so với thực tế, hoặc giải pháp elbow không đưa ra được một con số K đủ tốt để chọn. Các bạn có kinh nghiệm nào khi dùng MS thì chia sẻ thêm nhé.

Trong Mean Shift, bạn cũng chọn 1 số điểm để bắt đầu. Các điểm này sẽ dần dần dịch chuyển về khu vực có mật độ data dày hơn, như hình bên dưới. Bạn thấy là mấy cái chấm màu đen không dịch ra xa về phía khu vực có nhiều khoảng trống mà toàn dịch vào tâm của các điểm dữ liệu.


Điều này có được là do chúng dịch chuyển một khoảng = mean của các điểm nằm trong một khu vực mà bạn muốn xét (khu vực này gọi là window). Cũng vì phương thức dịch chuyển (shift) dựa vào mean nên thuật toán này mới có cái tên như trên. Sau khi lặp đi lặp lại nhiều lần, những điểm nằm trong cùng window sẽ được nhóm thành 1 nhóm.

MS có cái hay là bạn không cần chọn trước số nhóm cần phân loại. Thuật toán có thể tìm được số nhóm đó cho bạn luôn vì chúng sẽ dịch chuyển tự động.

Cái khó của MS là chọn window – bán kính vùng quét để tính mean – là bao nhiêu. Mình hiện đang dùng hàm estimate_bandwidth của SkLearn để chọn thông số này.

bandwidth = estimate_bandwidth(your_dataset, quantile=0.2, n_samples=500)

ms = MeanShift(bandwidth=bandwidth, bin_seeding=True)

labels = ms.labels_

cluster_centers = ms.cluster_centers_

labels_unique = np.unique(labels)

n_clusters_ = len(labels_unique)

#add the label back to the dataframe

df_run[‘meanshift_grouping_label’] = labels

print(“number of estimated clusters : %d” % n_clusters_)

Đang thấy có cái Agglomerative Hierarchical Clustering khá thú vị, để mình thử rồi có gì sẽ chia sẻ với các bạn trong bài viết mới.

Tài liệu

Mô hình hồi quy ứng dụng trong bài toán dự đoán giá bất động sản – Machine Learning (phần 2)

Mô hình hồi quy ứng dụng trong bài toán dự đoán giá bất động sản – Machine Learning (phần 2)

AlgorithmMachine LearningRegression Model


Xin chào tất cả các bạn. Ngày hôm nay chúng ta sẽ cùng nhau quay trở lại với serial về bài toán dự đoán trong học máy. Phần trước đó, các bạn có thể tham khảo ở đây. Trong bài này mình sẽ trình bày với các bạn về mô hình hồi quy và một ứng dụng cụ thể mình đã áp dụng trong một Project thực hiện trong quá trình Training tại Framgia Vietnam đó là ứng dụng định giá bất động sản. OK chúng ta bắt đầu nhé.

Vấn đề

  • Đã có một tập dữ liệu gồm các thuộc tính của bất động sản và giá của chúng
  • Các thuộc tính như: số phòng ngủ, số phòng tắm, vị trí địa lý, năm xây dựng…và giá bán
  • Giờ muốn tìm một công thức nào đó để từ một bất động sản bất kì, cho biết một vài thông tin như số phòng ngủ, vị trí địa lý… có thể tính toán ra được giá bán

Hướng giải quyết

OK, nếu các bạn đã theo dõi bài trước của mình thì sẽ thấy được qua ví dụ hoang tưởng là việc tính xổ số, chúng ta có thể ứng dụng chính mô hình đó cho tính giá bất động sản. Nói sơ qua một chút về lý thuyết cho các bạn hiểu về mô hình hồi quy nhé. Bản chất của hồi quy chính là tìm ra mối quan hệ nào đó giữa biến phụ thuộc (dependence) Y (ví dụ như kết quả xổ số hay giá nhà) và một hay nhiều biến độc lập X (independence) ví dụ như các thuộc tính của ngôi nhà chẳng hạn. Chúng ta cùng tìm hiểu một mô hình hồi quy đơn giản nhất đó chính là Hồi quy tuyến tính nhé.

Mô hình hồi quy tuyến tính


Đối với mô hình hồi quy tuyến tính, mô hình hóa sử dụng là dạng bậc nhất. Có nghĩa là chúng ta cần tính toán các hệ số Wi trong một biểu thức bậc nhất như sau:

Y = W0 + W1.X1 + W2.X2 + … + Wn.Xn

Tức là trên đồ thị chúng ta đi tìm một đường thẳng (nếu trường hợp có 1 biến độc lập) hoặc một siêu phẳng (với trường hợp nhiều biến độc lập) đi qua tập hợp các điểm trong không gian thuộc tính mà thể hiện gần đúng nhất sự phân bố của tập dữ liệu. Trên phương diện tính toán, chúng ta đi tìm các hệ số Wi như trên sao cho lỗi hồi quy đạt được là nhỏ nhất. Lại nói về lỗi hồi quy người ta thường sử dụng Phương pháp bình phương nhỏ nhất (least square). Các bạn có thể tham khảo thêm ở đây

Ứng dụng vào bài toán dự đoán giá bất động sản

Cái đầu tiên muốn nói gì thì nói chúng ta cần phải có một tập dữ liệu.Tập dữ liệu trong bài viết này các bạn có thể tìm thấy ở đây. File CSV này chứa thông tin về các bất động sản như số phòng ngủ, số phòng tắm, năm xây dựng… và giá bán tương ứng của nó. Chúng ta sẽ áp dụng lý thuyết về mô hình hồi quy để từ tập dữ liệu này, xây dựng một hàm sử dụng để định giá cho một bất động sản bất kì trong tương lai. OK chúng ta bắt đầu thôi.

Đọc dữ liệu từ file CSV

Trước tiên các bạn cần cài đặt Python và các thư viện cần thiết. Như phiên bản hiện tại mình đang sử dụng là Python 2.7 và Scikit-learn 0.18.1. Sau khi cài đặt các môi trường cần thiết. Chúng ta hãy viết một hàm để load dữ liệu từ file CSV bên trên như sau:

import os
import pandas as pd

def getData():
   # Get home data from CSV file
   dataFile = None
   if os.path.exists(‘home_data.csv’):
       print(“– home_data.csv found locally”)
       dataFile = pd.read_csv(‘home_data.csv’, skipfooter=1)

   return dataFile

Hàm trên sử dụng thư viện Pandas để load dữ liệu từ file CSV vào dưới dạng DataFrame

Lựa chọn thuộc tính và phân chia tập dữ liệu mẫu

Tư tưởng của chúng ta là sẽ phân chia tập dữ liệu mẫu thành hai tập con là tập dữ liệu huấn luyện và tập dữ liệu kiểm tra. Việc này sử dụng tư tưởng của kiểm tra chéo (cross validation). Ngoài ra, trong tập dữ liệu mẫu có rất nhiều thuộc tính có ý nghĩa và có thể khai thác thêm, ví dụ như từ kinh độ và vĩ độ chúng ta có thể tìm thêm các thuộc tính như khoảng cách trung tâm thành phố, số bệnh viện lân cận… Tuy nhiên trong bài viết này để cho đơn giản, mình lựa chọn một cách chủ quan một số thuộc tính mà mình cho rằng có thể có ảnh hưởng đến giá của bất động sản như số phòng ngủ, số phòng tắm, năm xây dựng và diện tích… Tất nhiên rằng, lựa chọn thuộc tính là một bài toán khác trong học máy, các bạn có thể tham khảo ở đây nhưng trong phạm vi bài viết này chúng ta chưa bàn đến nó.

data = getData()
   if data is not None:
       # Selection few attributes
       attributes = list(
       # Vector price of house
       Y = data[‘askprice’]
       # Vector attributes of house
       X = data[attributes]
       # Split data to training test and testing test
       X_train, X_test, Y_train, Y_test = train_test_split(np.array(X), np.array(Y), test_size=0.2)

Đoạn code bên trên phân chia tập dữ liệu thành 5 phần tương ứng 80% cho training và 20% cho testing. Việc cần làm tiếp theo là viết một hàm chạy Phương pháp hồi quy tuyến tính.

Áp dụng mô hình hồi quy tuyến tính


Về cơ bản, việc huấn luyện theo mô hình tuyến tính bản chất là đi tìm các giá trị m và b sao cho cực tiểu hóa hàm lỗi sau: 

Chúng ta sử dụng gói thư viện Scikit-learn của Python để làm việc này rất đơn giản như sau:

def linearRegressionModel(X_train, Y_train, X_test, Y_test):
   linear = linear_model.LinearRegression()
   # Training process, Y_train)
   # Evaluating the model
   score_trained = linear.score(X_test, Y_test)

   return score_trained

Hàm trên chạy mô hình hồi quy tuyến tính trên tập dữ liệu huấn luyện gồm X_train đại diện cho tập các thuộc tính của bất động sản và Y_train đại diện cho giá của nhà. Hàm trả về một giá trị đánh giá điểm của mô hình khi chạy trên tập kiểm tra. Về cơ bản, chúng ta có thể sử dụng điểm này để so sánh giữa các phương pháp hồi quy khác sẽ trình bày ở phần tiếp theo. Có nghĩa là điểm càng tiến gần đến 1 thì mô hình của chúng ta càng tốt.

Áp dụng mô hình hồi quy LASSO dạng chuẩn L1

Các dạng chuẩn (Regularization) thường được đưa vào các mô hình để nhằm giảm thiểu hiện tượng over-fitting. Nói về overfitting là cả một câu chuyện dài và mình hứa sẽ có dịp kể cho các bạn nghe về câu chuyện đó trên Viblo này. Chúng ta có thể hiểu nôm na như sau, một mô hình của chúng ta lựa chọn đang cố gắng giảm thiểu tối đa lỗi trên tập dữ liệu huấn luyện nhưng nó lại làm cho lỗi trên tập dữ liệu kiểm tra tăng lên. Và LASSO ra đời để hạn chế điều đó. Nó bổ sung thêm vào hàm lỗi của mô hình tuyến tính một đại lượng phạt lỗi lamda. Từ đó mô hình của chúng ta sẽ tìm các tham số phù hợp sao cho cực tiểu hóa hàm lỗi như sau:


Chúng ta sẽ viết một hàm tính toán điểm của phương pháp LASSO như sau:

def lassoRegressionModel(X_train, Y_train, X_test, Y_test):
   lasso_linear = linear_model.Lasso(alpha=1.0)
   # Training process, Y_train)
   # Evaluating the model
   score_trained = lasso_linear.score(X_test, Y_test)

Đánh giá hai mô hình hồi quy vừa áp dụng

Trong hàm main chúng ta chạy và so sánh hai hàm như sau:

if __name__ == “__main__”:
   data = getData()
   if data is not None:
       # Selection few attributes
       attributes = list(
       # Vector price of house
       Y = data[‘askprice’]
       # print np.array(Y)
       # Vector attributes of house
       X = data[attributes]
       # Split data to training test and testing test
       X_train, X_test, Y_train, Y_test = train_test_split(np.array(X), np.array(Y), test_size=0.2)
       # Linear Regression Model
       linearScore = linearRegressionModel(X_train, Y_train, X_test, Y_test)
       print ‘Linear Score = ‘ , linearScore
       # LASSO Regression Model
       lassoScore = lassoRegressionModel(X_train, Y_train, X_test, Y_test)
       print ‘Lasso Score = ‘, lassoScore

Kết quả chạy như sau:

Connected to pydev debugger (build 162.1967.10)
— home_data.csv found locally
Linear Score =  0.479529725484
Lasso Score =  0.479530220957
Process finished with exit code 0

Nếu dữ liệu và số lượng thuộc tính đủ lớn, ta có thể quan sát rõ tốc độ hội tụ của phương pháp Lasso nhanh hơn phương pháp hồi quy tuyến tính, nhờ vào cơ chế tính đạo hàm cho từng thuộc tính thay vì tính đạo hàm cùng lúc cho các thuộc tính. Cuối cùng, việc lựa chọn mô hình được dựa vào chỉ số đánh giá mô hình. Mô hình càng tốt thì model score càng gần đến 1.0.

Kết luận

Hồi quy là một phương pháp đơn giản và dễ áp dụng trong thực tế. Thực ra bài toán này còn có thể cải thiện hơn được nữa nhờ vào việc xấp xỉ căn bậc hai cho mô hình hay còn gọi là kĩ thuật nâng bậc cho mô hình tuyến tính mình sẽ tiếp tục trình bày trong các bài tiếp theo. Chúc các bạn cuối tuần vui vẻ. Xin chào tạm biệt và hẹn gặp lại.

Code và dữ liệu của bài viết

Các bạn cần tham khảo code áp dụng trong bài viết này và dữ liệu thì bơi vào đây

Tham khảo

Sklearn Regression

Coordinate descent

Gradient Descent

Tài liệu

Bài toán dự đoán (prediction) dựa trên mô hình hồi quy trong Machine Learning

Bài toán dự đoán (prediction) dựa trên mô hình hồi quy trong Machine Learning


Machine LearningAlgorithmMachine LearningThuật toán

Xin chào tất cả các bạn. Hôm nay mình xin được trở lại với các bạn trong một chủ đề khá hấp dẫn đó chính là Bài toán dự đoán (Prediction). Đây là một trong những lĩnh vực khá hay ho mà Machine Learning có thể làm được. OK, không dài dòng thêm nhiều nữa. Chúng ta bắt đầu thôi nào.

Học máy (Machine Learning) là gì?

Học máy hiểu đơn giản là tập hợp các phương pháp, các giải thuật khiến cho máy tính có thể tự “học”, tự “suy nghĩ” và đưa ra các quyết định giống như con người. Chính vì lý do đó người ta xếp Machine Learning (ML) thuộc vào phạm vi của lĩnh vực Trí tuệ nhân tạo. Người ta thường phân chia các thuật toán trong ML thành 2 dạng đó là (supervised learning) và (unsupervised learning). Mình sẽ trình bày sơ qua khái niệm này trong các phần tiếp theo để chúng ta có thể hiểu được một cách cơ bản nhất trước khi bước vào chủ để chính của bài viết này đó là thảo luận về Bài toán dự đoántrong ML. OK chúng ta tiếp tục thôi nào…

Học có hướng dẫn (Supervised Learning – SL)


Nhiều người đã dịch SL là học có giám sát, tuy nhiên mình thấy cách dịch này đôi khi làm khó hiểu cho những người mới tìm hiểu về ML. Thay vì đó, mình xin tạm dịch SL là học có hướng dẫn. Điều này nghĩa là sao? Có nghĩa là trong SL, chúng ta cần phải cung cấp cho máy tính một tập dữ liệu mấu (ví dụ như một tập hợp các câu hỏi và các câu trả lời đúng chẳng hạn). Sau đó chúng ta kì vòng rằng máy tính có thể thông qua các thuật toán, các mô hình được cài đặt để tìm ra các câu trả lời cho các câu hỏi chưa có đáp án trong tương lai. Đó chính là tư tưởng của bài toán dự đoán(prediction) mà chúng ta sắp thảo luận dưới đây. Để làm được việc này người ta thường tạo ra một tập dữ liệu chuẩn để làm tập dữ liệu huấn luyện (training dataset). Trên tập này chúng ta sẽ “hướng dẫn” cho máy tính “học” thông qua các mô hình mà chúng ta quy định. Các tham số sinh ra được từ tập dữ liệu huẩn luyện sẽ được sử dụng để thẩm định lại tính thích hợp của mô hình trên tập dữ liệu kiểm tra (testing dataset). Có hai lớp bài toán điển hình trong SL đó là hồi quy (regression) và phân lớp (Classification)

Học không cần hướng dẫn (Unsupervised Learning – USL)


Nếu như học có hướng dẫn chúng ta cần phải cung cấp cho máy tính một tập dữ liệu mẫu với các câu trả lời đúng cho từng câu hỏi (hướng dẫn) thì có những thuật toán trong USL không cần làm điều đó. Các thuật toán USL có khả năng khai thác cấu trúc ẩn của dữ liệu từ một tập dữ liệu chưa được gán nhãn trước (chưa có câu trả lời mẫu). Các hướng tiếp cận điển hình trong USL có thể kể đến như Phân cụmPhát hiện bất thườngMạng Nơ ron nhân tạo. OK vậy là chúng ta đã có một chút khái niệm cơ bản về học máy rồi phải không nào. Bây giờ chúng ta sẽ cùng nhau đi sâu tìm hiểu một lớp bài toán quan trọng trong ML đó chính là bài toán dự đoán dựa trên phương pháp hồi quy – một phương pháp nổi tiếng đã được nhắc đến trong phần Học có hướng dẫn ở trên.

Phân tích hồi quy

Bản chất của phân tích hồi quy chính là việc ước lượng mối quan hệ giữa các tham số (variables) trong mô hình mà chúng ta đang xét. Quay về trên quan điểm của xác suất thống kê, mình vẫn nhớ quan điểm của một người thầy rằng “Không có một sự kiện nào trên đời là ngẫu nhiên, những thứ đang cho là ngẫu nhiên chỉ là những sự kiện ta chưa tìm ra được mô hình để biểu diễn quy luật của chúng”. Hãy tạm coi như phát biểu của ông thầy kia là đúng và tưởng tượng chúng ta đang là những người đánh xổ số. Giả sử rằng chúng ta có thể tìm ra được mối liên hệ giữa kết quả xổ số của một ngày với một vài tham số dễ thương như sau:

  • Biến X1 biểu diễn số trẻ em sinh ra trong ngày hôm nay
  • Biến X2 biểu diễn số người chết đi trong ngày hôm nay
  • Biến X3 biểu diễn lượng mưa trong ngày hôm nay
  • Biến X4 biểu diễn số thằng bị thất tình trong ngày hôm nay

Và giả sử rằng kết quả xổ số của ngày hôm nay phụ thuộc một cách nào đó vào số người mới sinh, số người chết, lượng mưa và số thằng thất tình… Tức là chúng ta có thể viết dưới dạng toán học như sau:

Kết quả xổ số = f(X1, X2, X3, X4, …)

Hàm f của chúng ta là gì??? Đó là công việc của hàm hồi quy, việc của chúng ta đó là hãy sưu tập cho máy tính một tập dữ liệu gốc thật chuẩn (training dataset). Sau khi tìm ra được các tham số phụ thuộc ví dụ như:

Kết quả xổ số = 0.6X1 + 3X2 – 9X3 + 0.25X4 +…)

chúng ta sẽ sử dụng để so sánh nó trên tập dữ liệu kiểm tra (testing dataset). Thay đổi các phương pháp hồi quy cho đến khi sai số trên tập dữ liệu kiểm tra là nhỏ nhất. Như vậy chúng ta đã có một mô hình hồi quy sử dụng để tính toán kết quả xổ sổ rồi. Việc còn lại là tìm các giá trị cho X1, X2, X3…. áp vào mô hình rồi lấy kết quả đi đánh xổ số và tự tin với xác suất thắng lợi giống y như xác suất cao nhất bạn đạt trên tập dữ liệu kiểm tra. Qúa thú vị phải không nào. Hi vọng qua ví dụ hơi hoang tưởng trên bạn có thể hình dung ra được việc sử dụng phương pháp hồi quy trong bài toán dự đoán là như thế nào. Tất nhiên, trên thực tế người ta đã sử dụng mô hình hồi quy để ứng dụng vào các bài toán như:

  • Dự đoán giá cả của sản phẩm
  • Dự đoán biến động chứng khoán
  • Dự đoán thời tiết

Kết luận

Qua bài viết này mình muốn chia sẻ với các bạn những hiểu biết rất cơ bản về phương pháp hồi quy – một phương pháp đơn giản mà hiệu quả trong học máy được sử dụng cho bài toán dự đoán. Mình dự định sẽ viết sâu thêm về các thuật toán trong phương pháp hồi quy nói riêng và rộng hơn là các trong bài toán dự đoán nói chung. Rất mong được sự ủng hộ và theo dõi từ các bạn.

Tham khảo

Bài giảng Precdiction MIT

Machine Learning Documentation