Feature Detection with Harris Corner Detector and Matching images with Feature Descriptors in Python

The following problem appeared in a project in this Computer Vision Course (CS4670/5670, Spring 2015) at Cornell. In this article, a python implementation is going to be described. The description of the problem is taken (with some modifications) from the project description. The same problem appeared in this assignment problem as well. The images used for testing the algorithms implemented are mostly taken from these assignments / projects.

The Problem

In this project, we need to implement the problem of detect discriminating features in an image and find the best matching features in other images.  The features should be reasonably invariant to translation, rotation, and illumination.  The slides presented in class can be used as reference.

Description

The project has three parts:  feature detection, feature description, and feature matching.

1. Feature detection

In this step, we need to identify points of interest in the image using the Harris corner detection method.  The steps are as follows: 

  • For each point in the image, consider a window of pixels around that point.
  • Compute the Harris matrix H for (the window around) that point, defined asharriseq-structuretensor.pngwhere the summation is over all pixels p in the window.   is the x derivative of the image at point p, the notation is similar for the y derivative.
  •  The weights  are chosen to be circularly symmetric,  a 9×9 Gaussian kernel with 0.5 sigma is chosen to achieve this.
  • Note that H is a 2×2 matrix.  To find interest points, first we need to compute the corner strength function

  • Once c is computed for every point in the image, we need to choose points where c is above a threshold.
  • We also want c to be a local maximum in a 9×9 neighborhood (with non-maximum suppression).
  • In addition to computing the feature locations, we need to compute a canonical orientation for each feature, and then store this orientation (in degrees) in each feature element.
  • To compute the canonical orientation at each pixel, we need to compute the gradient of the blurred image and use the angle of the gradient as orientation.

2. Feature description

  • Now that the points of interest are identified,  the next step is to come up with a descriptor for the feature centered at each interest point.  This descriptor will be the representation to be used to compare features in different images to see if they match.
  • In this article, we shall implement a simple descriptor, a 8×8 square window without orientation. This should be very easy to implement and should work well when the images we’re comparing are related by a translation. We also normalize the window to have zero mean and unit variance, in order to obtain illumination invariance.
  • In order to obtain rotational invariance MOPS descriptor, by taking care of the orientation that is not discussed in this article for the time being.

3. Feature matching

  • Now that the features in the image are detected and described, the next step is to write code to match them, i.e., given a feature in one image, find the best matching feature in one or more other images.
  • The simplest approach is the following:  write a procedure that compares two features and outputs a distance between them.  For example, we simply sum the absolute value of differences between the descriptor elements.
  • We then use this distance to compute the best match between a feature in one image and the set of features in another image by finding the one with the smallest distance. The distance used here is the Manhattan distance.

 

The following theory and math for the Harris Corner Detection will be used that’s taken from this youtube video.

f19.png

 

Feature Detection (with Harris Corner Detection): Results on a few images

  • The threshold to be used for the Harris Corner Detection is varied (as shown in the following animations in red, with the value of the threshold being 10^x, where x is shown (the common logarithm of the threshold is displayed).
  • The corner strength function with kappa=0.04 is used instead of the minimum eigenvalue (since it’s faster to compute).
  • As can be seen from the following animations, lesser and lesser corner features are detected when the threshold is increased.
  • The direction and magnitude of the feature is shown by the bounding (green) square’s angle with the horizontal and the size of the square respectively, computed from the gradient matrices.

Input Imageflower.jpg

Harris Corner Features Detected for different threshold values (log10)
hcflw

Input Image
liberty3

Harris Corner Features Detected for different threshold values (log10)
hclib

Input Image
features_small.png

Harris Corner Features Detected for different threshold values (log10)hcfea

Input Image
chess

Harris Corner Features Detected for different threshold values (log10)

hcchs

Input Image
yosemite1.jpg

Harris Corner Features Detected for different threshold values (log10)
hcyos

Computing Feature descriptors

  • In this article, we shall implement a very simple descriptor, a 8×8 square window without orientation. This is expected to work well when the images being compared are related by a translation.
  • We also normalize the window to have zero mean and unit variance, in order to obtain illumination invariance.
  • In order to obtain rotational invariance MOPS descriptor, by taking care of the orientation that is not discussed in this article for the time being.

 

Matching Images with Detected Features: Results on a few images

The following examples show how the matching works with simple feature descriptors around the Harris corners for images obtained using mutual translations.

Input images (one is a translation of the other) 

liberty2           liberty1
Harris Corner Features Detected for the images
hc_0.000500liberty1hc_0.000500liberty2

Matched Features with minimum sum of absolute distancemhclib.gif

 

Input images
me        me3

Harris Corner Features Detected for the imageshc_0.000010me        hc_0.000010me3

Matched Features with minimum sum of absolute distance
mhcme.gif

The following example shows the input images to be compared being created more complex transformations (not only translation) and as expected, the simple feature descriptor does not work well in this case, as shown. We need some feature descriptors like SIFT to obtain robustness against rotation and scaling too.

Input images
trees_002  trees_003

Harris Corner Features Detected for the images
hc_0.000050trees_002   hc_0.000050trees_003

Matched Features with minimum sum of absolute distance
match_hc_403_trees_002.jpg

Advertisements

Seam Carving: Using Dynamic Programming to implement Content-Aware Image Resizing in Python

The following problem appeared as an assignment in the Algorithm Course (COS 226) at Princeton University taught by Prof. Sedgewick.  The following description of the problem is taken from the assignment itself.

The Seam Carving Problem

  • Seam-carving is a content-aware image resizing technique where the image is reduced in size by one pixel of height (or width) at a time.
  • vertical seam in an image is a path of pixels connected from the top to the bottom with one pixel in each row.
  • horizontal seam is a path of pixels connected from the left to the right with one pixel in each column.
  • Unlike standard content-agnostic resizing techniques (such as cropping and scaling), seam carving preserves the most interesting features (aspect ratio, set of objects present, etc.) of the image.
  • In this assignment, a data type needs to be created that resizes W-by-H image using the seam-carving technique.
  • Finding and removing a seam involves three parts:
    1. Energy calculation.The first step is to calculate the energy of a pixel, which is a measure of its importance—the higher the energy, the less likely that the pixel will be included as part of a seam (as you will see in the next step).In this assignment, we shall use the dual-gradient energy function, which is described below.Computing the energy of a pixel. With the dual-gradient energy function, the energy of  pixel (x,y) is  given by the following:f17.png
    2. Seam identification.The next step is to find a vertical seam of minimum total energy. (Finding a horizontal seam is analogous.) This is similar to the classic shortest path problem in an edge-weighted digraph, but there are three important differences:
      • The weights are on the vertices instead of the edges.
      • The goal is to find the shortest path from any of the W pixels in the top row to any of the W pixels in the bottom row.
      • The digraph is acyclic, where there is a downward edge from pixel (xy) to pixels (x − 1, y + 1), (xy + 1), and (x + 1, y + 1). assuming that the coordinates are in the prescribed ranges.
      • Also, Seams cannot wrap around the image (e.g., a vertical seam cannot cross from the leftmost column of the image to the rightmost column).
      • As described in the paper, the optimal seam can be found using dynamic programming. The first step is to traverse the image from the second row to the last row and compute the cumulative minimum energy M for all possible connected seams for each pixel (i, j):f18
    3. Seam removal.The final step is remove from the image all of the pixels along the vertical or horizontal seam.

Results with a few images

The following image is the original 507×284 pixel input image taken from the same assignment. The next few images and animations show the outputs of the seam carving algorithm implementation. The shape (the transpose of the image shape is reported) and size of the image (in terms of the memory taken by python np array as float, to store the image) is also reported for each iteration of the algorithm. As can be seen, the algorithm resizes the image by removing  the minimum energy vertical (and horizontal seams) iteratively one at a time, by keeping the main objects as is.

Input Original Image

HJoceanSmall.png

Removing the Vertical Seams

energy_000HJoceanSmall
vseam

After Removing 200 Vertical Seams

seam_199_vHJoceanSmall

energy

Removing the Vertical and the Horizontal Seams in alternating manner

vhseam
After Removing 100 Vertical Seams and 100 Horizontal Seams

seam_099_hHJoceanSmall

seam_099_vHJoceanSmall

The following is the original 1024×576 image of the Dakshineswar Temple, Kolkata along with the removed vertical seams with content-aware resizing.

temple

energy__temple
vseamtemple (2).gif

Output image after removing 500 Vertical Seams

seam_499_vtemple
The next animation again shows how the content-aware resizing preserves the objects in the original image.

vseam_sr

energy_000vr

The next image is the original dolphin 239×200 image taken from the paper, along with the removed vertical seams with content-aware resizing.

dolphin

energy_000dolphin.jpg

vseamdolphin

           After removing 112 Vertical Seams

seam_113_vdolphin

The next animation shows how the seams are deleted from the image in the reverse order of deletion.

vseamidolphin

 

The next image is the original 750×498 bird image taken from the paper, along with the removed vertical seams with content-aware resizing.

bird2.png

energy_000bird2.png

vseambird
         After Removing 297 Vertical Seams

seam_299_vbird2

 

The next image is the original 450×299 sea image taken from the paper, along with the removed vertical seams with content-aware resizing.

sea2.png

vseamsea2

 

The next image is the original 628×413 cycle image taken from the paper, along with the removed vertical seams with content-aware resizing.

cycle.png

energy_000cycle

vseamcycle

After Removing 99 Vertical Seams

seam_199_vcycle

 

The next image is the original 697×706 Fuji image again taken from the paper, along with the removed vertical seams with content-aware resizing.

Fuji

 

vseamfuji

               After Removing 282 Vertical Seams

seam_280_vFuji

 

Object Removal

The same technique can be applied with mask to remove objects from an image. For example. consider the following image of the shoes taken from the same paper.

shoes

Let’s use a black mask to remove a shoe that we don’t want, as shown in the next figure.

masked_shoes.jpg
Finally the vertical seams can be forced to go through the masked object, as shown in the next animation,  in order to remove the masked object completely just by using context-aware resizing.

or_shoes.gif

Output after removing the shoe with content-aware image resize algorithm

seam_115_vshoes.jpg

Measuring Semantic Relatedness using the Distance and the Shortest Common Ancestor and Outcast Detection with Wordnet Digraph in Python

The following problem appeared as an assignment in the Algorithm Course (COS 226) at Princeton University taught by Prof. Sedgewick.  The description of the problem is taken from the assignment itself. However, in the assignment, the implementation is supposed to be in java, in this article a python implementation will be described instead. Instead of using nltk, this implementation is going to be from scratch.

 

The Problem

 

  • WordNet is a semantic lexicon for the English language that computational linguists and cognitive scientists use extensively. For example, WordNet was a key component in IBM’s Jeopardy-playing Watson computer system.
  • WordNet groups words into sets of synonyms called synsets. For example, { AND circuitAND gate } is a synset that represent a logical gate that fires only when all of its inputs fire.
  • WordNet also describes semantic relationships between synsets. One such relationship is the is-a relationship, which connects a hyponym (more specific synset) to a hypernym (more general synset). For example, the synset gatelogic gate } is a hypernym of { AND circuitAND gate } because an AND gate is a kind of logic gate.
  • The WordNet digraph. The first task is to build the WordNet digraph: each vertex v is an integer that represents a synset, and each directed edge v→w represents that w is a hypernym of v.
  • The WordNet digraph is a rooted DAG: it is acyclic and has one vertex—the root— that is an ancestor of every other vertex.
  • However, it is not necessarily a tree because a synset can have more than one hypernym. A small subgraph of the WordNet digraph appears below.

 

wordnet-event.png

 

The WordNet input file formats

 

The following two data files will be used to create the WordNet digraph. The files are in comma-separated values (CSV) format: each line contains a sequence of fields, separated by commas.

  • List of synsets: The file synsets.txt contains all noun synsets in WordNet, one per line. Line i of the file (counting from 0) contains the information for synset i.
    • The first field is the synset id, which is always the integer i;
    • the second field is the synonym set (or synset); and
    • the third field is its dictionary definition (or gloss), which is not relevant to this assignment.

      wordnet-synsets.png

      For example, line 36 means that the synset { AND_circuitAND_gate } has an id number of 36 and its gloss is a circuit in a computer that fires only when all of its inputs fire. The individual nouns that constitute a synset are separated by spaces. If a noun contains more than one word, the underscore character connects the words (and not the space character).
  • List of hypernyms: The file hypernyms.txt contains the hypernym relationships. Line i of the file (counting from 0) contains the hypernyms of synset i.
    • The first field is the synset id, which is always the integer i;
    • subsequent fields are the id numbers of the synset’s hypernyms.

      wordnet-hypernyms.png

      For example, line 36 means that synset 36 (AND_circuit AND_Gate) has 42338 (gate logic_gate) as its only hypernym. Line 34 means that synset 34 (AIDS acquired_immune_deficiency_syndrome) has two hypernyms: 47569 (immunodeficiency) and 56099 (infectious_disease).

 

 

The WordNet data type 

 

Implement an immutable data type WordNet with the following API:

wn.png

 

  • The Wordnet Digraph contains 76066 nodes and 84087 edges, it’s very difficult to visualize the entire graph at once, hence small subgraphs will be displayed as and when required relevant to the context of the examples later.

 

  • The sca() and the distance() between two nodes v and w are implemented using bfs (bread first search) starting from the two nodes separately and combining the distances computed.

 

Performance requirements 

  • The data type must use space linear in the input size (size of synsets and hypernyms files).
  • The constructor must take time linearithmic (or better) in the input size.
  • The method isNoun() must run in time logarithmic (or better) in the number of nouns.
  • The methods distance() and sca() must make exactly one call to the length() and ancestor() methods in ShortestCommonAncestor, respectively.


The Shortest Common Ancestor
 

 

  • An ancestral path between two vertices v and w in a rooted DAG is a directed path from v to a common ancestor x, together with a directed path from w to the same ancestor x.
  • shortest ancestral path is an ancestral path of minimum total length.
  • We refer to the common ancestor in a shortest ancestral path as a shortest common ancestor.
  • Note that a shortest common ancestor always exists because the root is an ancestor of every vertex. Note also that an ancestral path is a path, but not a directed path.

wordnet-sca.png

  • The following animation shows how the shortest common ancestor node 1 for the nodes 3 and 10  for the following rooted DAG is found at distance 4 with bfs, along with the ancestral path 3-1-5-9-10.sca2.gif
  • The following animation shows how the shortest common ancestor node 5 for the nodes 8 and 11  for the following rooted DAG is found at distance 3 with bfs, along with the ancestral path 8-5-9-11.sca1.gif
  • The following animation shows how the shortest common ancestor node 0 for the nodes 2 and for the following rooted DAG is found at distance 4 with bfs, along with the ancestral path 6-3-1-0-2.sca3.gif
      
  • We generalize the notion of shortest common ancestor to subsets of vertices. A shortest ancestral path of two subsets of vertices A and B is a shortest ancestral path over all pairs of vertices v and w, with v in A and w in B.
  • The figure (digraph25.txt) below shows an example in which, for two subsets, red and blue, we have computed several (but not all) ancestral paths, including the shortest one.wordnet-sca-set.png

     

  • The following animation shows how the shortest common ancestor node 3 for the set of nodes {13, 23, 24} and {6, 16, 17}  for the following rooted DAG is found at associated length (distance) with bfs, along with the ancestral path 13-7-3-9-16.sca4Shortest common ancestor data type

     

    Implement an immutable data type ShortestCommonAncestor with the following API:

    sca.png

 

Basic performance requirements 

The data type must use space proportional to E + V, where E and V are the number of edges and vertices in the digraph, respectively. All methods and the constructor must take time proportional to EV (or better).

 

Measuring the semantic relatedness of two nouns

Semantic relatedness refers to the degree to which two concepts are related. Measuring semantic relatedness is a challenging problem. For example, let’s consider George W. Bushand John F. Kennedy (two U.S. presidents) to be more closely related than George W. Bush and chimpanzee (two primates). It might not be clear whether George W. Bush and Eric Arthur Blair are more related than two arbitrary people. However, both George W. Bush and Eric Arthur Blair (a.k.a. George Orwell) are famous communicators and, therefore, closely related.

Let’s define the semantic relatedness of two WordNet nouns x and y as follows:

  • A = set of synsets in which x appears
  • B = set of synsets in which y appears
  • distance(x, y) = length of shortest ancestral path of subsets A and B
  • sca(x, y) = a shortest common ancestor of subsets A and B

This is the notion of distance that we need to use to implement the distance() and sca() methods in the WordNet data type.

wordnet-distance.png

 

Finding semantic relatedness for some example nouns with the shortest common ancestor and the distance method implemented

 

apple and potato (distance 5 in the Wordnet Digraph, as shown below)

dag_apple_potato.png

As can be seen, the noun entity is the root of the Wordnet DAG.

beer and diaper (distance 13 in the Wordnet Digraph)

dag_beer_diaper.png

 

beer and milk (distance 4 in the Wordnet Digraph, with SCA as drink synset), as expected since they are more semantically closer to each other.

dag_beer_milk.png

bread and butter (distance 3 in the Wordnet Digraph, as shown below)

dag_bread_butter.png

cancer and AIDS (distance 6 in the Wordnet Digraph, with SCA as disease as shown below, bfs computed distances and the target distance between the nouns are also shown)

dag_cancer_AIDS.png

 

car and vehicle (distance 2 in the Wordnet Digraph, with SCA as vehicle as shown below)

dag_car_vehicle.png
cat and dog (distance 4 in the Wordnet Digraph, with SCA as carnivore as shown below)

dag_cat_dog.png

cat and milk (distance 7 in the Wordnet Digraph, with SCA as substance as shown below, here cat is identified as Arabian tea)

dag_cat_milk.png

 

Einstein and Newton (distance 2 in the Wordnet Digraph, with SCA as physicist as shown below)

dag_Einstein_Newton

Leibnitz and Newton (distance 2 in the Wordnet Digraph, with SCA as mathematician)

dag_Leibnitz_Newton

Gandhi and Mandela (distance 2 in the Wordnet Digraph, with SCA as national_leader synset)dag_Gandhi_Mandela

laptop and internet (distance 11 in the Wordnet Digraph, with SCA as instrumentation synset)dag_laptop_internet

school and office (distance 5 in the Wordnet Digraph, with SCA as construction synset as shown below)

dag_school_office

bed and table (distance 3 in the Wordnet Digraph, with SCA as furniture synset as shown below)
dag_table_bed

Tagore and Einstein (distance 4 in the Wordnet Digraph, with SCA as intellectual synset as shown below)

dag_Tagore_Einstein

Tagore and Gandhi (distance 8 in the Wordnet Digraph, with SCA as person synset as shown below)

dag_Tagore_Gandhi

Tagore and Shelley (distance 2 in the Wordnet Digraph, with SCA as author as shown below)
dag_Tagore_Shelley

text and mining (distance 12 in the Wordnet Digraph, with SCA as abstraction synset as shown below)
dag_text_mining

milk and water (distance 3 in the Wordnet Digraph, with SCA as food, as shown below)dag_water_milk

Outcast detection

 

Given a list of WordNet nouns x1x2, …, xn, which noun is the least related to the others? To identify an outcast, compute the sum of the distances between each noun and every other one:

di   =   distance(xix1)   +   distance(xix2)   +   …   +   distance(xixn)

and return a noun xt for which dt is maximum. Note that distance(xixi) = 0, so it will not contribute to the sum.

Implement an immutable data type Outcast with the following API:

outc.png

 

Examples

As expected, potato is the outcast  in the list of the nouns shown below (a noun with maximum distance from the rest of the nouns, all of which except potato are fruits, but potato is not). It can be seen from the Wordnet Distance heatmap from the next plot, as well as the sum of distance plot from the plot following the next one.
outcast_apple_pear_peach_banana_lime_lemon_blueberry_strawberry_mango_watermelon_potato

dag_apple_bananadag_strawberry_bananadag_strawberry_blueberry

dag_apple_potatodag_strawberry_potato

Again, as expected, table is the outcast  in the list of the nouns shown below (a noun with maximum distance from the rest of the nouns, all of which except table are mammals, but table is not). It can be seen from the Wordnet Distance heatmap from the next plot, as well as the sum of distance plot from the plot following the next one.

outcast_horse_zebra_cat_bear_table

dag_cat_beardag_cat_tabledag_horse_zebra

Finally, as expected, bed is the outcast  in the list of the nouns shown below (a noun with maximum distance from the rest of the nouns, all of which except bed are drinks, but bed is not). It can be seen from the Wordnet Distance heatmap from the next plot, as well as the sum of distance plot from the plot following the next one.

outcast_water_soda_bed_orange_juice_milk_apple_juice_tea_coffee

dag_bed_tea

dag_orange_juice_tea

Some more Variational Image Processing: Diffusion, TV Denoising, TV Image Inpainting in Python

In this article, a few variational image processing techniques will  be described along with application of those techniques with some images, most of the problems are taken from the assignments from this course.

 

Some preliminaries: The Calculus of Images – Computing Curvature and TV

 

  • Let’s first compute the Euclidian Curvature of a few images.  The curvature measures the rate at which the unit gradient vector is changing and is given byf11.png
  • The following couple of images are used to compute the curvature. As can be seen from the below figures, the curvature is zero in flat regions and along straight edges and non-zero along the rounded edges of the circles, as expected.cur_testcur_source
  • Now, let’s compute the total variation (TV), which is given by the following.f12.png
  • First we need to approximate the partial derivatives using a forward difference.
  • Let’s compute the TV for the grayscale image Cameraman. Now let’s add more and more Salt & Pepper noise (by increasing the probability threshold p) to the image and see how the norm of the gradient matrix along with the TV value changes from the following figure.cam
    tv_Cameraman256.png

The Heat Equation and Diffusion

Let’s implement the isotropic and anisotropic diffusion by solving PDEs numerically.
The following figure shows the math.

f13.png

The following shows the isotropic diffusion output with Δt = 0.1, with gradient descent.  As can be seen, the results are same as applying gaussian blur kernel on the image.

iso_cam.gif

The following shows the anisotropic diffusion output with Δt = 0.1, with gradient descent, with a = 5, 20, 100 respectively.  As can be seen, unlike isotropic diffusion, the anisotropic diffusion preserves the edges.

aniso_cam_5

aniso_cam_20

aniso_cam_100

Creating Cartoon / flat-texture Images with Anisotropic Diffusion

As can be seen from the following figures and animations, we can create cartoons from the real images with anisotropic diffusion, by applying the diffusion on each channel, this time on color images (the barbara image and my image).

Original image

barbara

Cartoon Image with anisotropic diffusion (a=5)

aniso_barbara_020.0_5

aniso_bar_col_10

Original Image

me2

Cartoon Image with anisotropic diffusion (a=5)

aniso_me2_020.0_5

 

 

me_col_7.5

Total Variation Denoising

The following math is going to be used for TV denoising, the Euler-Lagrange equation is used to solve the minimum of the functional, as shown in the following figures with proof.

f14.pngf9

f10.png

  • First a noisy grayscale image is prepared by adding Gaussian noise to the cameraman image.

 

Original Cameraman
Cameraman256

Noisy Cameraman

noisy_cam

 

  • Let’s first denoise this image with linear TV denoising. The next animations show the results obtained , using the fidelity weight λ=1. As can be seen, even with the fidelity term, this model blurs the edges.tvld_cam.gif
  • Now let’s denoise this image with Nonlinear TV denoising. The next animations show the results obtained , using the fidelity weight λ=0.01 and λ=1 respectively.tvn_cam_0.01.gif
    tvn_cam_1

 

Image Inpainting

Inpainting is the process of restoring damaged or missing parts of an image. Suppose we have a binary mask D that specifies the location of the damaged pixels in the input image f as shown below:

f15.png

The following theory is going to be used for TV inpainting.

f16.png

Damaged image  

tampered_cmask1_Cameraman256

cam_in0

Damaged image  

tampered_cmask2_Cameraman256cam_in1

Damaged image  

tampered_text_Cameraman256cam_in2cam_in2

Damaged image
tampered_lena2

lena_in.gif

tv_inpaint_gd_tampered_lena2.png

Some Variational Image Processing: Poisson Image Editing and its applications in Python

Poisson Image Editing

The goal of Poisson image editing is to perform seamless blending of an object or a texture from a source image (captured by a mask image) to a target image. We want to create a photomontage by pasting an image region onto a new background using Poisson image editing. This idea is from the P´erez et al’s SIGGRAPH 2003 paper Poisson Image Editing.

The following figures describe the basic theory. As can be seen, the problem is first expressed in the continuous domain as a constrained variational optimization problem (Euler-Lagrange equation is used to find a solution) and then can be solved using a discrete Poisson solver.

f7.png

 

f8.png

 

As described in the paper and also in this assignment from this MIT course on Computational Photography, the main task of Poisson image editing is to solve a huge linear system Ax = b (where I is the new unknown image and S and T are the known images).

 

Seamless Cloning

The following images are taken from an assignment  from the same MIT course, where the Poisson image editing had to be used to blend the source inside the mask inside the target image. The next few figures show the result obtained.

Source Imagebear

Mask Imagemask

Target Imagewaterpool

Output Gray-Scale Image with Poisson Image Editing
pe_waterpool

The next animation shows the solution gray-scale images obtained at different iterations using Conjugate Gradient method when solving the linear system of equations.

peditmit1

Output Color Image with Poisson Image Editingpe_waterpool_color1

The next animation shows the solution color images obtained at different iterations using Conjugate Gradient method to solve the linear system of equations, applying the discrete Poisson solver on each channel.

pbear.gif

 

 

The following images are taken from this UNC course on computational photography. Again, the same technique is used to blend the octopus from the source image to the target image.

Source Imagesource

Mask Imagemask

Target Imagetarget

Output Imagepe_target_color

The next animation shows the solution color images obtained at different iterations using Conjugate Gradient method to solve the linear system of equations, applying the discrete Poisson solver on each channel.

poct.gif

 

Again, Poisson gradient domain seamless cloning was used to blend the penguins’ image  inside the following target image with appropriate mask.

Source Image
peng1

Target Image                                                                                                            trekking

Output Imagepe_trekking.jpg

The next animation again shows the solution color images obtained at different iterations using Conjugate Gradient method to solve the linear system of equations, applying the discrete Poisson solver on each channel.

pe-trekk

 

The next figures show how a source bird image is blended into the target cloud image with seamless cloning.

Source Image
bird1

Target Imagecloud

Output gray-scale imagepe_cloud

The next animation shows the solution gray-scale images obtained at the first few iterations using Conjugate Gradient method when solving the linear system of equations.

pedit2

 

Finally, the next figures show how the idol of the Goddess Durga is blended into the target image of the city of kolkata with seamless cloning. As can be seen, since the source mask had its own texture and there is a lots of variations in the background texture, the seamless cloning does not work that well.

Source Image
madurga

Target Image
kol

Output Image
pe_kol_color

The next animation shows the solution gray-scale images obtained at the first few iterations using Conjugate Gradient method when solving the linear system of equations.

pedit

The next animation again shows the solution color images obtained at different iterations using Conjugate Gradient method while solving the linear system of equations, applying the discrete Poisson solver on each channel.

pe-madurga

 

Feature Cloning: Inserting objects

The next figures are taken from the same paper, here the eyes, nose and lips from the  source face image is going to be inserted into the target monalisa face.

  Source image          Target image         Output image
face mona pe_mona

The next animation again shows the solution color images obtained at different iterations using Conjugate Gradient method while solving the linear system of equations, applying the discrete Poisson solver on each channel.

pe-mona

 

Texture Swapping: Feature exchange with Seamless Cloning

As discussed in the paper, seamless cloning allows the user to replace easily certain features of one object by alternative features. The next figure shows how the texture of the other fruit was transferred to the orange, the images being taken from the same paper.

Source Image        Target Image        Mask Image
sfruit   dfruit    fmask

Output Image
pe_dfruit

The next animation again shows the solution color images obtained at different iterations using Conjugate Gradient method while solving the linear system of equations, applying the discrete Poisson solver on each channel.

pfruit

 

Gradient Mixing: Inserting objects with holes

Again, the next figures are taken from the same paper, this time the source objects contain holes. As can be seen from the following results, the seamless cloning does not work well in this case for inserting the object with holes into the target, the target texture is lost inside the mask after blending.

Source Image                                            Target Image
srch            dsth

Output Image with Poisson Seamless Cloning
pe_tran1

The next animation again shows the solution color images obtained at the first few iterations using Conjugate Gradient method while solving the linear system of equations for seamless cloning, applying the discrete Poisson solver on each channel.

pe-tran1

Using the mixing gradients method the blending result obtained is far better, as shown below, it preserves the target texture.

Output Image with Poisson Mixing Gradients
pe_tran

The next animation again shows the solution color images obtained at the first few iterations using Conjugate Gradient method while solving the linear system of equations for mixing gradients, applying the discrete Poisson solver on each channel.

pe-tran

 

Mixing Gradients: Inserting transparent objects

The next example shows the insertion of a rainbow into a target image, the images are taken from the paper again. As can be seen, the seamless cloning wrongly places the rainbow in front of the coconut tree in the target image. Using gradient mixing, the stronger gradient is used as the image gradient and this solves the issue.

 

    Source Image                              Target Image                         Mask Imagerainbow    sky1      rmask

Output Image with Seamless Cloning
pe_sky
Output Image with Mixing Gradients
pe_rainbow

The next animation again shows the solution color images obtained at the first few iterations using Conjugate Gradient method while solving the linear system of equations for mixing gradients, applying the discrete Poisson solver on each channel.

pe-rainbow

 

The next few figures show the results obtained using mixing gradients on another set of images, the seamless cloning does not work well in this case, but mixing gradient works just fine.

 

Source Image
liberty1

Target Image
vic

Output Image with mixing gradients
pe_vic

The next animation again shows the solution color images obtained at the first few iterations using Conjugate Gradient method while solving the linear system of equations for mixing gradients, applying the discrete Poisson solver on each channel.

pe-vic

Texture Flattening: Creating Flat-texture Cartoon-like images

As illustrated in the paper, by retaining only the gradients at edge locations, before integrating with the Poisson solver, one washes out the texture of the selected region, giving its contents a flat aspect.

The following figures show the output cartoon-like image obtained using texture flattening, using the canny-edge detector to generate the  mask.

Source Image
pe_face1

Mask Image created with Canny edge detector
mface1

Output cartoon obtained with texture flattening from the source with the mask
pe_cart1

The next animation shows the solution color images obtained at the first few iterations using Conjugate Gradient method while solving the linear system of equations for texture flattening, applying the discrete Poisson solver on each channel.

pe-cart1

 

Again, the next figures show the output cartoon-like image obtained using texture flattening, using the canny-edge detector to generate the  mask on my image.

Source Image
me2

Output image obtained with texture flattening
pe-cart-me

The next animation again shows the solution color images obtained at the first few iterations using Conjugate Gradient method while solving the linear system of equations for texture flattening, applying the discrete Poisson solver on each channel.

pe-cart-me

 

Some more Social Network Analysis with Python: Centrality, PageRank/HITS, Random Network Generation Models, Link Prediction

In this article, some more social networking concepts will be illustrated with a few problems. The problems appeared in the programming assignments in the
coursera course Applied Social Network Analysis in Python.  The descriptions of the problems are taken from the assignments. The analysis is done using NetworkX.

The following theory is going to be used to solve the assignment problems.

 

f01.png

1. Measures of  Centrality

In this assignment, we explore measures of centrality on the following two networks:

  1. A friendship network
  2. A political blog network.

 

  • First let’s do some analysis with different centrality measures using the friendship network, which is a network of friendships at a university department. Each node corresponds to a person, and an edge indicates friendship. The following figure visualizes the network, with the size of the nodes proportional to the degree of the nodes.

 

f33.png

Degree Centrality

The next figure shows the distribution of the degree centrality of the nodes in the friendship network graph.

f34.png
The following figure visualizes the network, with the size of the nodes again
proportional to the degree centrality of the nodes.
f35.png

Closeness Centrality

The next figure shows the distribution of the closeness centrality of the nodes in the friendship network graph.

f36.png

 

The following figure again visualizes the network, with the size of the nodes being
proportional to the closeness centrality of the nodes.

f37.png

 

 

Betweenness Centrality

The next figure shows the distribution of the betweenness centrality of the nodes in the friendship network graph.

 

f38.png

 

The following figure again visualizes the network, with the size of the nodes being
proportional to the betweenness centrality of the nodes.

 

f39.png

 

  • Now, let’s consider another network, which is a directed network of political blogs, where nodes correspond to a blog and edges correspond to links between blogs.
  • This network will be used to compute  the following:
    • PageRank of the nodes using random walk with damping factor.
    • Authority and Hub Score of the nodes using the HITS.
  • The blog network looks like the following:
    source value
    tsrightdominion.blogspot.com Blogarama 1
    rightrainbow.com Blogarama 1
    gregpalast.com LabeledManually 0
    younglibs.com Blogarama 0
    blotts.org/polilog Blogarama 0
    marylandpolitics.blogspot.com BlogCatalog 1
    blogitics.com eTalkingHead 0
    thesakeofargument.com Blogarama 1
    joebrent.blogspot.com Blogarama 0
    thesiliconmind.blogspot.com Blogarama 0
    40ozblog.blogspot.com Blogarama,BlogCatalog 0
    progressivetrail.org/blog.shtml Blogarama 0
    randomjottings.net eTalkingHead 1
    sonsoftherepublic.com Blogarama 1
    rightvoices.com CampaignLine 1
    84rules.blog-city.com eTalkingHead 1
    blogs.salon.com/0002874 LeftyDirectory 0
    alvintostig.typepad.com eTalkingHead 0
    notgeniuses.com CampaignLine 0
    democratreport.blogspot.com BlogCatalog 0
  • First let’s visualize the network, next figure shows the visualization. The network has nodes (blogs) from 47 different unique sources, each node belonging to a source is colored with a unique color. The gray lines denote the edges (links) between the nodes (blogs).

f40.png

  • The next figure shows the same network graph, but without the node labels (blog urls).

f41.png

Page-Rank and HITS

  • Now, let’s apply the Scaled Page Rank Algorithm to this network.,with damping value 0.85. The following figure visualizes the graph with the node size proportional to the page rank of the node.f42.png
  • The next animations show how the page rank of the nodes in the network changes with the first 25 iterations of the power-iteration algorithm.

 

anipranipr1

  • The top 5 nodes with the highest page rank values after 25 iterations of the power-iteration page-rank algorithm are shown below, along with their ranks scores.
    • (u’dailykos.com’, 0.020416972184975967)
    • (u’atrios.blogspot.com’, 0.019232277371918939)
    • (u’instapundit.com’, 0.015715941717833914)
    • (u’talkingpointsmemo.com’, 0.0152621016868163)
    • (u’washingtonmonthly.com’, 0.013848910355057181)

 

  • The top 10 nodes with the highest page rank values after the convergence of the  page-rank algorithm are shown below, along with their ranks scores.
    • (u’dailykos.com’, 0.01790144388519838)
    • (u’atrios.blogspot.com’, 0.015178631721614688)
    • (u’instapundit.com’, 0.01262709066072975)
    • (u’blogsforbush.com’, 0.012508582138399093)
    • (u’talkingpointsmemo.com’, 0.012393033204751035)
    • (u’michellemalkin.com’, 0.010918873519905312)
    • (u’drudgereport.com’, 0.010712415519898428)
    • (u’washingtonmonthly.com’, 0.010512012551452737)
    • (u’powerlineblog.com’, 0.008939228332543162)
    • (u’andrewsullivan.com’, 0.00860773822610682)

 

  • The following figure shows the distribution of the page-ranks of the nodes after the convergence of the algorithm.f43.png

 

  • Next, let’s apply the HITS Algorithm to the network to find the hub and authority scores of node.
  • The following couple of figures visualizes the network graph where the node size is proportional to the hub score and the authority score for the node respectively, once the HITS algorithm converges.f44f45
  • Next couple of figures show the distribution of the hub-scores and the authority-scores for the nodes once the HITS converges.

 

  • f46f47

 

 

2. Random Graph Identification

 

Given a list containing 5 networkx graphs., with each of these graphs being generated by one of three possible algorithms:

  • Preferential Attachment ('PA')
  • Small World with low probability of rewiring ('SW_L')
  • Small World with high probability of rewiring ('SW_H')

Anaylze each of the 5 graphs and determine which of the three algorithms generated the graph.

The following figures visualize all the graphs along with their degree-distributions. Since the Preferential Attachment model generates graphs with the node degrees following  the power-law distribution (since rich gets richer), the graphs with this pattern in their degree distributions are most likely generated by this model.

On the other hand, the Small World model generates graphs with the node degrees not following the power-law distribution, instead the distribution shows fat tails. If this pattern is seen, we can identify the network as to be generated with this model.
f23f24f25f26f27f28f29f30f31f32

 

3. Prediction using Machine Learning models with the graph-centrality and local clustering features

 

For this assignment we need to work with a company’s email network where each node corresponds to a person at the company, and each edge indicates that at least one email has been sent between two people.

The network also contains the node attributes Department and ManagmentSalary.

Department indicates the department in the company which the person belongs to, and ManagmentSalary indicates whether that person is receiving a managment position salary. The email-network graph has

  • Number of nodes: 1005
  • Number of edges: 16706
  • Average degree: 33.2458

The following figure visualizes the email network graph.

f48.png

Salary Prediction

Using network G, identify the people in the network with missing values for the node attribute ManagementSalary and predict whether or not these individuals are receiving a managment position salary.

To accomplish this, we shall need to

  • Create a matrix of node features
  • Train a (sklearn) classifier on nodes that have ManagementSalary data and
  • Predict a probability of the node receiving a managment salary for nodes where ManagementSalary is missing.

The predictions will need to be given as the probability that the corresponding employee is receiving a managment position salary.

The evaluation metric for this assignment is the Area Under the ROC Curve (AUC).

A model needs to achieve an AUC of 0.75 on the test dataset.

Using the trained classifier, return a series with the data being the probability of receiving managment salary, and the index being the node id (from the test dataset).

The next table shows first few rows of the dataset with the degree and clustering features computed. The dataset contains a few ManagementSalary values are missing (NAN), the corresponding tuples form the test dataset, for which we need to predict the missing ManagementSalary values. The rest will be the training dataset.

Now,  a few classifiers will be trained on the training dataset , they are:

  • RandomForest
  • SVM
  • GradientBoosting

with 3 input features for each node:

  • Department
  • Clustering (local clustering coefficient for the node)
  • Degree

in order to predict the output variable as the indicator receiving  managment salary.

 

 Index Department ManagementSalary clustering degree
0 1 0.0 0.276423 44
1 1 NaN 0.265306 52
2 21 NaN 0.297803 95
3 21 1.0 0.384910 71
4 21 1.0 0.318691 96
5 25 NaN 0.107002 171
6 25 1.0 0.155183 115
7 14 0.0 0.287785 72
8 14 NaN 0.447059 37
9 14 0.0 0.425320 40

 

Typical 70-30 validation is used for model selection. The next 3 tables show the first few rows of the train, validation and the test datasets respectively.

 

Department clustering degree ManagementSalary
421 14 0.227755 52 0
972 15 0.000000 2 0
322 17 0.578462 28 0
431 37 0.426877 25 0
506 14 0.282514 63 0
634 21 0.000000 3 0
130 0 0.342857 37 0
140 17 0.394062 41 0
338 13 0.350820 63 0
117 6 0.274510 20 0
114 10 0.279137 142 1
869 7 0.733333 6 0
593 5 0.368177 42 0
925 10 0.794118 19 1
566 14 0.450216 22 0
572 4 0.391304 26 0
16 34 0.284709 74 0
58 21 0.294256 126 1
57 21 0.415385 67 1
207 4 0.505291 30 0

 

 Index Department clustering degree ManagementSalary
952 15 0.533333 8 0
859 32 0.388106 74 1
490 6 0.451220 43 0
98 16 0.525692 25 0
273 17 0.502463 31 0
784 28 0.000000 3 0
750 20 0.000000 1 0
328 8 0.432749 21 0
411 28 0.208364 106 1
908 5 0.566154 28 0
679 29 0.424837 20 0
905 1 0.821429 10 0
453 6 0.427419 34 1
956 14 0.485714 15 0
816 13 0.476190 23 0
127 6 0.341270 28 0
699 14 0.452899 26 0
711 21 0.000000 2 0
123 13 0.365419 36 0
243 19 0.334118 53 0
Department clustering degree
1 1 0.265306 52
2 21 0.297803 95
5 25 0.107002 171
8 14 0.447059 37
14 4 0.215784 80
18 1 0.301188 56
27 11 0.368852 63
30 11 0.402797 68
31 11 0.412234 50
34 11 0.637931 31

The following table shows the first few predicted probabilities  by  the RandomForest classifier on the test dataset.

 Index 0 1
0 1.0 0.0
1 0.2 0.8
2 0.0 1.0
3 1.0 0.0
4 0.5 0.5
5 1.0 0.0
6 0.7 0.3
7 0.7 0.3
8 0.3 0.7
9 0.7 0.3
10 0.9 0.1
11 0.8 0.2
12 1.0 0.0
13 0.6 0.4
14 0.7 0.3
15 0.5 0.5
16 0.0 1.0
17 0.2 0.8
18 1.0 0.0
19 1.0 0.0

 

The next figure shows the ROC curve to compare the performances (AUC) of the classifiers on the validation dataset.

As can be seen, the GradientBoosting  classifier performs the best (has the highest AUC on the validation dataset).

 

f49.png

 

The following figure shows the Decision Surface for the Salary Prediction learnt by the RandomForest Classifier.

f50.png

 

4. New Connections Prediction (Link Prediction with ML models)

For the last part of this assignment, we shall predict future connections between employees of the network. The future connections information has been loaded into the variable future_connections. The index is a tuple indicating a pair of nodes that currently do not have a connection, and the FutureConnectioncolumn indicates if an edge between those two nodes will exist in the future, where a value of 1.0 indicates a future connection. The next table shows first few rows of the dataset.

 Index Future Connection
(6, 840) 0.0
(4, 197) 0.0
(620, 979) 0.0
(519, 872) 0.0
(382, 423) 0.0
(97, 226) 1.0
(349, 905) 0.0
(429, 860) 0.0
(309, 989) 0.0
(468, 880) 0.0

 

Using network G and future_connections, identify the edges  in future_connections
with missing values and predict whether or not these edges will have a future connection.

To accomplish this, we shall need to

  1. Create a matrix of features for the edges found in future_connections
  2. Train a (sklearn) classifier on those edges in future_connections that have Future Connection data
  3. Predict a probability of the edge being a future connection for those edges in future_connections where Future Connection is missing.

The predictions will need to be given as the probability of the corresponding edge being a future connection.

The evaluation metric for this assignment is again the Area Under the ROC Curve (AUC).

Using the trained classifier, return a series with the data being the probability of the edge being a future connection, and the index being the edge as represented by a tuple of nodes.

Now,  a couple of classifiers will be trained on the training dataset , they are:

  • RandomForest
  • GradientBoosting

with 2 input features for each edge:

  • Preferential attachment
  • Common Neighbors

in order to predict the output variable Future Connection.

The next table shows first few rows of the dataset with the preferential attachment and Common Neighbors  features computed.

 Index Future Connection preferential attachment Common Neighbors
(6, 840) 0.0 2070 9
(4, 197) 0.0 3552 2
(620, 979) 0.0 28 0
(519, 872) 0.0 299 2
(382, 423) 0.0 205 0
(97, 226) 1.0 1575 4
(349, 905) 0.0 240 0
(429, 860) 0.0 816 0
(309, 989) 0.0 184 0
(468, 880) 0.0 672 1
(228, 715) 0.0 110 0
(397, 488) 0.0 418 0
(253, 570) 0.0 882 0
(435, 791) 0.0 96 1
(711, 737) 0.0 6 0
(263, 884) 0.0 192 0
(342, 473) 1.0 8140 12
(523, 941) 0.0 19 0
(157, 189) 0.0 6004 5
(542, 757) 0.0 90 0

 

Again, typical 70-30 validation is used for model selection. The next 3 tables show the first few rows of the train, validation and the test datasets respectively.

 

preferential attachment Common Neighbors Future Connection
(7, 793) 360 0 0
(171, 311) 1620 1 0
(548, 651) 684 2 0
(364, 988) 18 0 0
(217, 981) 648 0 0
(73, 398) 124 0 0
(284, 837) 132 1 0
(748, 771) 272 4 0
(79, 838) 88 0 0
(207, 716) 90 1 1
(270, 928) 15 0 0
(201, 762) 57 0 0
(593, 620) 168 1 0
(494, 533) 18212 40 1
(70, 995) 18 0 0
(867, 997) 12 0 0
(437, 752) 205 0 0
(442, 650) 28 0 0
(341, 900) 351 0 0
(471, 684) 28 0 0

 

 Index preferential attachment Common Neighbors Future Connection
(225, 382) 150 0 0
(219, 444) 594 0 0
(911, 999) 3 0 0
(363, 668) 57 0 0
(161, 612) 2408 4 0
(98, 519) 575 0 0
(59, 623) 636 0 0
(373, 408) 2576 6 0
(948, 981) 27 0 0
(690, 759) 44 0 0
(54, 618) 765 0 0
(149, 865) 330 0 0
(562, 1001) 320 1 1
(84, 195) 4884 10 1
(421, 766) 260 0 0
(599, 632) 70 0 0
(814, 893) 10 0 0
(386, 704) 24 0 0
(294, 709) 75 0 0
(164, 840) 864 3 0

 

preferential attachment Common Neighbors
(107, 348) 884 2
(542, 751) 126 0
(20, 426) 4440 10
(50, 989) 68 0
(942, 986) 6 0
(324, 857) 76 0
(13, 710) 3600 6
(19, 271) 5040 6
(319, 878) 48 0
(659, 707) 120 0

The next figure shows the ROC curve to compare the performances (AUC) of the classifiers on the validation dataset.

As can be seen, the GradientBoosting  classifier again performs the best (has the highest AUC on the validation dataset).

f51.png

 

The following figure shows the Decision Boundary for the Link Prediction learnt by the RandomForest Classifier.

f52.png

Some Social Network Analysis with Python

The following problems appeared in the programming assignments in the coursera course Applied Social Network Analysis in Python.  The descriptions of the problems are taken from the assignments. The analysis is done using NetworkX.

The following theory is going to be used to solve the assignment problems.

f0.png

1. Creating and Manipulating Graphs

  • Eight employees at a small company were asked to choose 3 movies that they would most enjoy watching for the upcoming company movie night. These choices are stored in a text file Employee_Movie_Choices , the following figure shows the content of the file.
     Index Employee Movie
    0 Andy Anaconda
    1 Andy Mean Girls
    2 Andy The Matrix
    3 Claude Anaconda
    4 Claude Monty Python and the Holy Grail
    5 Claude Snakes on a Plane
    6 Frida The Matrix
    7 Frida The Shawshank Redemption
    8 Frida The Social Network
    9 Georgia Anaconda
    10 Georgia Monty Python and the Holy Grail
    11 Georgia Snakes on a Plane
    12 Joan Forrest Gump
    13 Joan Kung Fu Panda
    14 Joan Mean Girls
    15 Lee Forrest Gump
    16 Lee Kung Fu Panda
    17 Lee Mean Girls
    18 Pablo The Dark Knight
    19 Pablo The Matrix
    20 Pablo The Shawshank Redemption
    21 Vincent The Godfather
    22 Vincent The Shawshank Redemption
    23 Vincent The Social Network
  • A second text file, Employee_Relationships, has data on the relationships between different coworkers.  The relationship score has value of -100 (Enemies) to +100 (Best Friends). A value of zero means the two employees haven’t interacted or are indifferent. The next figure shows the content of this file.

 

 Index Employee1 Employee2 Score
0 Andy Claude 0
1 Andy Frida 20
2 Andy Georgia -10
3 Andy Joan 30
4 Andy Lee -10
5 Andy Pablo -10
6 Andy Vincent 20
7 Claude Frida 0
8 Claude Georgia 90
9 Claude Joan 0
10 Claude Lee 0
11 Claude Pablo 10
12 Claude Vincent 0
13 Frida Georgia 0
14 Frida Joan 0
15 Frida Lee 0
16 Frida Pablo 50
17 Frida Vincent 60
18 Georgia Joan 0
19 Georgia Lee 10
20 Georgia Pablo 0
21 Georgia Vincent 0
22 Joan Lee 70
23 Joan Pablo 0
24 Joan Vincent 10
25 Lee Pablo 0
26 Lee Vincent 0
27 Pablo Vincent -20
0 Claude Andy 0
1 Frida Andy 20
2 Georgia Andy -10
3 Joan Andy 30
4 Lee Andy -10
5 Pablo Andy -10
6 Vincent Andy 20
7 Frida Claude 0
8 Georgia Claude 90
9 Joan Claude 0
10 Lee Claude 0
11 Pablo Claude 10
12 Vincent Claude 0
13 Georgia Frida 0
14 Joan Frida 0
15 Lee Frida 0
16 Pablo Frida 50
17 Vincent Frida 60
18 Joan Georgia 0
19 Lee Georgia 10
20 Pablo Georgia 0
21 Vincent Georgia 0
22 Lee Joan 70
23 Pablo Joan 0
24 Vincent Joan 10
25 Pablo Lee 0
26 Vincent Lee 0
27 Vincent Pablo -20
  • First, let’s load the bipartite graph from Employee_Movie_Choices file, the following figure visualizes the graph. The blue nodes represent the employees and the red nodes represent the movies.

f1.png

 

  • The following figure shows yet another visualization of the same graph, this time with a different layout.f2.png
  • Now, let’s find a weighted projection of the graph which tells us how many movies different pairs of employees have in common. We need to compute an L-bipartite projection for this, the projected graph is shown in the next figure.f3.png
  • The following figure shows the same projected graph with another layout and with weights. For example, Lee and Joan has the weight 3 for their connecting edges, since they share 3 movies in common as their movie-choices.f4.png

 

  • Next, let’s load the graph from Employee_Relationships  file, the following figure visualizes the graph. The nodes represent the employees and the edge colors and widths (weights) represent the relationships. The green edges denote friendship, the red edges enmity and blue edges neutral relations. Also, the thicker an edge is, the more powerful is a +ve or a -ve relation.f5.png
  • Suppose we like to find out if people that have a high relationship score also like the same types of movies.
  • Let’s find the Pearson correlation between employee relationship scores and the number of movies they have in common. If two employees have no movies in common it should be treated as a 0, not a missing value, and should be included in the correlation calculation.
  • The following data frame is created from the graphs and will be used to compute the correlation.
     Index Employee1 Employee2 Relationship Score Weight in Projected Graph
    0 Andy Claude 0 1.0
    1 Andy Frida 20 1.0
    2 Andy Georgia -10 1.0
    3 Andy Joan 30 1.0
    4 Andy Lee -10 1.0
    5 Andy Pablo -10 1.0
    6 Andy Vincent 20 0.0
    7 Claude Frida 0 0.0
    8 Claude Georgia 90 3.0
    9 Claude Joan 0 0.0
    10 Claude Lee 0 0.0
    11 Claude Pablo 10 0.0
    12 Claude Vincent 0 0.0
    13 Frida Georgia 0 0.0
    14 Frida Joan 0 0.0
    15 Frida Lee 0 0.0
    16 Frida Pablo 50 2.0
    17 Frida Vincent 60 2.0
    18 Georgia Joan 0 0.0
    19 Georgia Lee 10 0.0
    20 Georgia Pablo 0 0.0
    21 Georgia Vincent 0 0.0
    22 Joan Lee 70 3.0
    23 Joan Pablo 0 0.0
    24 Joan Vincent 10 0.0
    25 Lee Pablo 0 0.0
    26 Lee Vincent 0 0.0
    27 Pablo Vincent -20 1.0
    28 Claude Andy 0 1.0
    29 Frida Andy 20 1.0
    30 Georgia Andy -10 1.0
    31 Joan Andy 30 1.0
    32 Lee Andy -10 1.0
    33 Pablo Andy -10 1.0
    34 Vincent Andy 20 0.0
    35 Frida Claude 0 0.0
    36 Georgia Claude 90 3.0
    37 Joan Claude 0 0.0
    38 Lee Claude 0 0.0
    39 Pablo Claude 10 0.0
    40 Vincent Claude 0 0.0
    41 Georgia Frida 0 0.0
    42 Joan Frida 0 0.0
    43 Lee Frida 0 0.0
    44 Pablo Frida 50 2.0
    45 Vincent Frida 60 2.0
    46 Joan Georgia 0 0.0
    47 Lee Georgia 10 0.0
    48 Pablo Georgia 0 0.0
    49 Vincent Georgia 0 0.0
    50 Lee Joan 70 3.0
    51 Pablo Joan 0 0.0
    52 Vincent Joan 10 0.0
    53 Pablo Lee 0 0.0
    54 Vincent Lee 0 0.0
    55 Vincent Pablo -20 1.0
  • The correlation score is 0.788396222173 which is a pretty strong correlation. The following figure shows the association between the two variables with a fitted regression line.

    f6.png 

 

2. Network Connectivity

 

  • In this assignment we shall go through the process of importing and analyzing an internal email communication network between employees of a mid-sized manufacturing company.

    Each node represents an employee and each directed edge between two nodes represents an individual email. The left node represents the sender and the right node represents the recipient, as shown in the next figure.

    f7.png

  •  First let’s load the email-network as a directed multigraph and visualize the graph in the next figure. The graph contains 167 nodes (employees) and 82927 edges (emails sent). The size of a node in the figure is proportional to the out-degree of the node.f8.png

 

  • The next couple of figures visualize the same network with different layouts.f9.png

    f10.png

     

  • Assume that information in this company can only be exchanged through email.When an employee sends an email to another employee, a communication channel has been created, allowing the sender to provide information to the receiver, but not vice versa.Based on the emails sent in the data, is it possible for information to go from every employee to every other employee?

    This will only be possible if the graph is strongly connected, but it’s not. The following figure shows 42 strongly-connected components (SCC) of the graph. Each SCC is shown using a distinct color.

     
    f11.png

    As can be seen from the following histogram, only one SCC contains 126 nodes, each of the remaining 41 SCCs contains exactly one node.

    f12.png

  • Now assume that a communication channel established by an email allows information to be exchanged both ways.Based on the emails sent in the data, is it possible for information to go from every employee to every other employee?This is possible since the graph is weakly connected. 
  • The following figure shows the subgraph  induced by the largest SCC with 126 nodes.f13.png
  • The next figure shows the distribution of the (shortest-path) distances between the node-pairs in the largest SCC.f14.png

    As can be seen from above, inside the largest SCC, all  the nodes are reachable from one another with at most 3 hops, the average distance between any node pairs belonging to the SCC being 1.6461587301587302.

  • Diameter of the largest SCC: The largest possible distance between two employees, which is 3.
  • Find the set of nodes in the subgraph with eccentricity equal to the diameter: these are exactly the nodes that are on the periphery. As can be seen from the next figure (the largest component is shown along with few other nodes from some other components in the graph, all the nodes and edges in the graph are not shown to avoid over-crowding), there are exactly 3 nodes on the periphery of the SCC, namely the node 97, 129 and 134.Each of the following 3 shortest paths shown in the next figure
    • 97->14->113->133
    • 129->1->38->132 and
    • 134->1->38->132

    has length equal to the diameter of this SCC.

    f15.png

 

  • Center of the largest SCC: The set of node(s) in the subgraph induced by the largest SCC with eccentricity equal to the radius (which is 1). There is exactly one such node (namely, node 38), as shown in the next figure, all the nodes belonging to the largest SCC are distance-1 reachable from the center node 38 (again, the largest component is shown along with few other nodes from some other components in the graph, all the nodes and edges in the graph are not shown to avoid over-crowding).f16.png
  • The following figure shows the distribution of eccentricity in the largest SCC.f17.png
  • Which node in the largest SCC has the most shortest paths to other nodes whose distance equal the diameter ?  How many of these paths are there?As can be seen from the following figure, the desired node is 97 and there are 63 such shortest paths that have length equal to the diameter of the SCC,  5 of such paths (each with length 3) are shown in the next figure, they are:
    • 97->14->113->133
    • 97->14->113->130
    • 97->14->113->136
    • 97->14->45->131
    • 97->14->45->132
      .f18.png
  • Suppose we want to prevent communication from flowing to the node 97 (the node that has the most shortest paths to other nodes whose distance equal the diameter), from any node in the center of the largest component, what is the smallest number of nodes we would need to remove from the graph (we’re not allowed to remove the node 97 or the center node(s))?

    As obvious, the minimum number of nodes required to be removed exactly equals to the size of the min-cut with the source node (center node 38) to the target node (node 97), shown in red in the next figure. The size of the min-cut is 5 and hence 5 nodes (shown in pale-golden-red color) need to be removed, the corresponding node numbers are: 14, 32, 37, 45 and 46. As done in the earlier figures, all the nodes and edges in the email-net graph are not shown to avoid over-crowding.

    emails_comp5.png

    The min-cut is separately shown in the following figure from source node 38 to target node 97.

    emails_comp4

  • Construct an undirected graph from the subgraph induced by the largest component on the email-net directed multi-graph. 

    The next figure shows the undirected graph constructed. As before, the node size is proportional to the degree of the node.f19.png

  • What is the transitivity and average clustering coefficient of the undirected graph?The transitivity and average clustering coefficient of the undirected graph are 0.570111160700385 and 0.6975272437231418 respectively.

    The following figure shows the distribution of the local clustering coefficients.

    f20.png

    The following figure shows the undirected graph, this time the node size being proportional to the local clustering coefficient of the node.

    f21.png

    The next figure shows the degree distribution of the undirected graph.

    f22.png

    Since there are more nodes with lower degrees than with higher degrees and the transitivity weights the nodes with higher degree more, the undirected graph has  lower transitivity and higher average clustering coefficient.

Implementing kd-tree for fast range-search, nearest-neighbor search and k-nearest-neighbor search algorithms in 2D (with applications in simulating the flocking boids: modeling the motion of a flock of birds and in learning a kNN classifier: a supervised ML model for binary classification) in Java and python

The following problem appeared as an assignment in the coursera course Algorithms-I by Prof. Robert Sedgewick from the Princeton University few years back (and also in the course cos226 offered at Princeton). The problem definition and the description is taken from the course website and lectures.  The original assignment was to be done in java, where in this article both the java and a corresponding python implementation will also be described.

  • Use a 2d-tree to support
    • efficient range search (find all of the points contained in a query rectangle)
    • nearest-neighbor search (find a closest point to a query point).

    2d-trees have numerous applications, ranging from classifying astronomical objects to computer animation to speeding up neural networks to mining data to image retrieval. The figure below describes the problem:

    kdtree-ops.png

    2d-tree implementation: A 2d-tree is a generalization of a BST to two-dimensional keys. The idea is to build a BST with points in the nodes, using the x– and y-coordinates of the points as keys in strictly alternating sequence, starting with the x-coordinates, as shown in the next figure.

    kdtree3

    • Search and insert. The algorithms for search and insert are similar to those for BSTs, but at the root we use the x-coordinate (if the point to be inserted has a smaller x-coordinate than the point at the root, go left; otherwise go right); then at the next level, we use the y-coordinate (if the point to be inserted has a smaller y-coordinate than the point in the node, go left; otherwise go right); then at the next level the x-coordinate, and so forth.
    • The prime advantage of a 2d-tree over a BST is that it supports efficient implementation of range search and nearest-neighbor search. Each node corresponds to an axis-aligned rectangle, which encloses all of the points in its subtree. The root corresponds to the entire plane [(−∞, −∞), (+∞, +∞ )]; the left and right children of the root correspond to the two rectangles split by the x-coordinate of the point at the root; and so forth.
      • Range search: To find all points contained in a given query rectangle, start at the root and recursively search for points in both subtrees using the following pruning rule: if the query rectangle does not intersect the rectangle corresponding to a node, there is no need to explore that node (or its subtrees). That is, search a subtree only if it might contain a point contained in the query rectangle.
      • Nearest-neighbor search: To find a closest point to a given query point, start at the root and recursively search in both subtrees using the following pruning rule: if the closest point discovered so far is closer than the distance between the query point and the rectangle corresponding to a node, there is no need to explore that node (or its subtrees). That is, search a node only if it might contain a point that is closer than the best one found so far. The effectiveness of the pruning rule depends on quickly finding a nearby point. To do this, organize the recursive method so that when there are two possible subtrees to go down, you choose first the subtree that is on the same side of the splitting line as the query point; the closest point found while exploring the first subtree may enable pruning of the second subtree.
      • k-nearest neighbors search: This method returns the k points that are closest to the query point (in any order); return all n points in the data structure if n ≤ k. It must do this in an efficient manner, i.e. using the technique from kd-tree nearest neighbor search, not from brute force.
      • BoidSimulator: Once the  k-nearest neighbors search we can simulate boids: how a flock of birds flies together and a hawk predates. Behold their flocking majesty.The following figures show the theory that are going to be used, taken from the lecture slides of the same course.

    f1f2f3f4

    f5

    Results

    The following figures and animations show how the 2-d-tree is grown with recursive space-partioning for a few sample datasets.

  • Circle 10 dataset

circle10

test1test2test3test4test6test7test8test9

  • Circle 100 dataset

circle100.gif

test1test6test16test32test64test72test99
The following figure shows the result of the range search algorithm on the same dataset after the 2d-tree is grown. The yellow points are the points found by the algorithm inside the query rectangle shown.

test-range

The next animations show the nearest neighbor search algorithm for a given query point (the fixed white point with black border: the point (0.3, 0.9)) and how the the branches are traversed and the points (nodes) are visited in the 2-d-tree until the nearest neighbor is found.

nn.gif

nearest1.gif

The next animation shows how the kd-tree is traversed for nearest-neighbor search for a different query point (0.04, 0.7).

nearest2

The next figures show the result of k-nearest-neighbor search, by extending the previous algorithm with different values of k (15, 10, 5 respectively).

test_knn2test_knn3test_knn4

 

Runtime of the algorithms with a few datasets in Python

As can be seen from the next figure, the time complexity of 2-d tree building (insertion), nearest neighbor search and k-nearest neighbor query depend  not only on the size of the datasets but also on the geometry of the datasets .

runtime.png

 

Flocking Boids simulator

Finally the flocking boids simulator is implemented with 2-d-trees and the following 2 animations (java and python respectively) shows how the flock of birds fly together, the black / white ones are the boids and the red one is the predator hawk.

birds

birds1

 

Implementing a kNN Classifier with kd tree from scratch

Training phase

Build a 2d-tree from a labeled 2D training dataset (points marked with red or blue represent 2 different class labels).

Testing phase

  • For a query point (new test point with unknown class label) run k-nearest neighbor search on the 2d-tree with the query point (for a fixed value of k, e.g., 3).
  • Take a majority vote on the class labels of the k-nearest neighbors (with known class labels) obtained by querying the 2d-tree. Label the query point with the class label that majority of its neighbors have.
  • Repeat for different values of k.

 

The following figures show how the kd tree built can be used to classify (randomly generated) 2D datasets and the decision boundaries are learnt with k=3, 5 and 10 respectively.

test_classification3test_classification5test_classification10

Using Particle Filter for localization: tracking objects from noisy measurements in 2D (in R)

In this article, we shall see how the Particle Filter can be used to predict positions of some moving objects using a few sampled particles in 2D.  This article is inspired by a programming assignment from the coursera course Robotics Learning by University of Pennsylvania. The same algorithm is often used for self-localization of a robot from the noisy sensor measurements.

The basic idea for the Particle Filter is described in the figure below, taken from  this video by Bert Huang.

p1.png

 

The next few figures, taken from the lectures of the Coursera Course Robotics Learning again describe the basics of particle filter.

p2.png
p3p4

  • The particle filter algorithm is described in the next figure, taken from a lecture video by udacity.p5

 

  • The next set of figures / animations show how the position of a moving bug is tracked using Particle Filter.
    • First the noisy measurements of the positions of the bug are obtained at different time instants.
    • Then M=100 particles are sampled and later they are propagated  based upon some prior assumptions on position uncertainty..
    • Next the noisy measurement for the particle is computed (simulated by adding random noise to the true position).
    • Measurement update step: For each particle, the probability of the particle is calculated to update the particle weights, assuming some measurement noise.
    • Next the best particle is chosen to update the pose.
    • Re-sampling step:  if the effective number of particles is smaller than a threshold (e.g., 0.8),  the particles are re-sampled.
    • Next the particles along with the probability-weights are used to compute the estimated location (e.g., computing the weighted average of the particle positions).
    • The next animation shows the steps, the probability cloud represents the density over the particles chosen at each step.motion2
    • The position of the bug as shown in the animation above is moving in  the x and direction randomly in a grid defined by  the rectangle
      [-100,100]x[-100,100].
    • The above figure also shows how at different iterations the Particle Filter predicts the position of the bug.
    • The next animation shows the density of the particles for a different measurement uncertainty.

motion1.gif

Unsupervised Deep learning with AutoEncoders on the MNIST dataset (with Tensorflow in Python)

  • Deep learning,  although primarily used for supervised classification / regression problems, can also be used as an unsupervised ML technique, the autoencoder being a classic example. As explained here,  the aim of an autoencoder is to learn a representation (encoding) for a set of data, typically for the purpose of  dimensionality reduction.
  • Deep learning can be used to learn a different representation (typically a set of input features in a  low-dimensional space) of the data that can be used for pre-training for example in transfer-learning.
  • In this article, a few vanilla autoencoder implementations will be demonstrated for the mnist dataset.
  • The following figures describe the theory (ref: coursera course Neural Networks for Machine Learning, 2012 by Prof. Hinton, university of Toronto). As explained, the autoencoder with back-propagation-based implementation can be used to generalize the linear dimension-reduction techniques as PCA, since the hidden layers can learn non-linear manifolds with non-linear activation functions (e.g., relu , sigmoid).

 

p2p3

 

  • The input and output units of an autoencoder are identical, the idea is to learn the input itself as a different representation with one or multiple hidden layer(s).
  • The mnist images are of size 28×28, so the number of nodes in the input and the output layer are always 784 for the autoencoders shown in this article.
  • The left side of an auto-encoder network is typically a mirror image of the right side and the weights are tied (weights learnt in the left hand side of the network are reused, to better reproduce the input at the output).
  • The next figures and animations show the outputs for the following simple autoencoder with just 1 hidden layer, with the input mnist data. A Relu activation function is used in the hidden layer.  It also uses the L2 regularization on the weights learnt. As can be seen from the next figure, the inputs are kind of reproduced with some variation at the output layer, as expected.

aec1
a1i_0.001

a1o_0.001

  • The next animations visualize the hidden layer weights learnt (for the 400 hidden units) and the output of the autoencoder with the same input training dataset, with a different value of the regularization parameter.

 

a1h_10

a1o_10

 

  • The next figure visualizes the hidden layer weights learnt with yet another different regulariation parameter value.

 

hidden

 

  • The next animation visualizes the output of the autoencoder with the same input training dataset, but this time no activation function  being used at the hidden layer.

 

a1o_0.001.na

  • The next animations show the results with a deeper autoencoder with 3 hidden layers (the architecture shown below). As before, the weights are tied and in this case no activation function is used, with L2 regularization on the weights.

 

aec2

a2i_0.001a2o_0.001

 

  • Let’s implement a more deeper autoencoder. The next animations show the results with a deeper autoencoder with 5 hidden layers (the architecture shown below). As before, the weights are tied and in this case no activation function is used, with L2 regularization on the weights.

 

aec3
a2i_0.001a3o_0.00001