Forem: Banso D. Wisdom

2020: My Year In Review

Banso D. Wisdom — Sat, 26 Dec 2020 13:07:02 +0000

See you next year!

2019: My year in review

Banso D. Wisdom — Tue, 31 Dec 2019 18:42:27 +0000

Understanding the Confusion Matrix (II)

Banso D. Wisdom — Sun, 05 May 2019 18:40:28 +0000

In the first part of this article, I talked about the confusion matrix in general, the 2-class confusion matrix, how to calculate accuracy, precision and other metrics using it and also how to generate a confusion matrix in python.

In this article, we'll be looking at the multi-class confusion matrix.

What is the multi-class confusion matrix?

As the name implies, it is a confusion matrix that deals with multiple classes (i.e. more than 2 classes). Just like the 2-class confusion matrix, it describes the performance of a multi-class classification model.

For the purpose of this article, we'll be assuming that our multi-class classification model is one that classifies images of dogs into the following breeds: Greyhound, Mastiff and Samoyed.

A confusion matrix for this classifier can be visualized as such:

In this visualization, we have two sections which have been outlined. We have the predicted classifications section which contains three subsections for each of the classes we want to classify into and the actual classifications section which has three subsections for each of the classes.

Having visualized this confusion matrix, we can use this visualization to calculate the following metrics:

True Positives.
True Negatives.
False Positives.
False Negatives.
Accuracy.
Precision.
True Positive Rate is also known as Sensitivity or Recall.
True Negative Rate is also known as Specificity.

Before we calculate these metrics, let's define the variables in the visualization:

PGG
This variable represents the number of predictions where images of a Greyhound were correctly classified [as a Greyhound]. This is also the True Positive for the Greyhound class.

PMG
This variable represents the number of predictions where images of a Greyhound were incorrectly classified as a Mastiff.

PSG
This variable represents the number of predictions where images of a Greyhound were incorrectly classified as a Samoyed.

PGM
This variable represents the number of predictions where images of a Mastiff were incorrectly classified as a Greyhound.

PMM
This variable represents the number of predictions where images of a Mastiff were correctly classified [as a Mastiff]. This is also the True Positive for the Mastiff class.

PSM
This variable represents the number of predictions where images of a Mastiff were incorrectly classified as a Samoyed.

PGS
This variable represents the number of predictions where images of a Samoyed were incorrectly classified as a Greyhound.

PMS
This variable represents the number of predictions where images of a Samoyed were incorrectly classified as a Mastiff.

PSS
This variable represents the number of predictions where images of a Samoyed were correctly classified [as a Samoyed]. This is also the True Positive for the Samoyed class.

Now that we have defined these variables, we can now calculate the aforementioned metrics.

True Positives

The definition for the True Positive is the same as in the 2-class confusion matrix. However, here we calculate the True Positives for each class in the confusion matrix unlike the general or absolute True Positives in the 2-class confusion matrix.

The True Positives is the number of predictions where data labelled to belong to a particular class was correctly classified as the said class. E.g Number of predictions where images of a Samoyed was correctly classified as a Samoyed.

From the definition of the matrix variables, we have already identified the True Positives for each of the classes:

True Positives for the Greyhound class is the variable PGG in the confusion matrix.

True Positives for the Mastiff class is the variable PMM in the confusion matrix.

True Positives for the Samoyed class is the variable PSS in the confusion matrix.

True Negatives

The definition of the True Negative is the same as in the 2-class confusion matrix. Here we calculate the True Negatives for each class in the confusion matrix unlike the general or absolute True Negatives in the 2-class confusion matrix.

The True Negatives for a particular class is calculated by taking the sum of the values in every row and column except the row and column of the class we're trying to find the True Negatives for.

For example, calculating the True Negatives for the Greyhound class:

We omit the row and columns belonging to the Greyhound class and sum the variables that are left, which are the rows and columns of the other classes (Mastiff and Samoyed).

Therefore the True Negatives for the Greyhound class is:

TN = PMM + PSM + PMS + PSS

Similarly, we can calculate the True Negatives for the other classes.

Calculating the True Negatives for the Mastiff class:

The True Negatives for the Mastiff class is:

TN = PGG + PSG + PGS + PSS

Calculating the True Negatives for the Samoyed class:

The True Negatives for the Samoyed class is:

TN = PGG + PMG + PGM + PMM

False Positives

The definition of the False Positive is the same as in the 2-class confusion matrix. Here we calculate the False Positives for each class in the confusion matrix unlike the general or absolute False Positives in the 2-class confusion matrix.

The False Positives for a particular class can be calculated by taking the sum of all the values in the column corresponding to that class except the True Positives value.

For example, calculating the False Positives for the Greyhound class:

We sum all the values in the highlighted area, which is the column corresponding to the Greyhound class with the exception of the variable PGG which we had earlier identified to be the True Positives for the Greyhound class.

Therefore the False Positives for Greyhound class is:

FP = PGM + PGS

Similarly, we can calculate the False Positives for the other classes.

Calculating the False Positives for the Mastiff class:

The False Positives for the Mastiff class is:

FP = PMG + PMS

Calculating the False Positives for the Samoyed class:

The False Positives for the Samoyed class is:

FP = PSG + PSM

False Negatives

The definition of the False Negative is the same as in the 2-class confusion matrix. Here we calculate the False Negatives for each class in the confusion matrix unlike the general or absolute False Positives in the 2-class confusion matrix.

The False Negatives for a particular class can be calculated by taking the sum of all the values in the row corresponding to that class except the True Positives value.

For example, calculating the False Negatives for the Greyhound class:

We sum all the values in the highlighted area, which is the row corresponding to the Greyhound class with the exception of the variable PGG which we had earlier identified to be the True Positives for the Greyhound class.

Therefore the False Negatives for Greyhound class is:

FN = PMG + PSG

Similarly, we can calculate the False Negatives for the other classes.

Calculating the False Negatives for the Mastiff class:

The False Negatives for the Mastiff class is:

FN = PGM + PSM

Calculating the False Negatives for the Samoyed class:

The False Negatives for the Samoyed class is:

FN = PGS + PMS

Accuracy

Accuracy is calculated as the ratio of the number of correct classifications to the total number of classifications. From our confusion matrix, the correct classifications are the True Positives and True Negatives for each class and the total number of classifications is the sum of every value in the confusion matrix, including the True Positives.

Therefore, the accuracy is:

Where:

TP(x) is the True Positives value for a class.
TN(x) is the True Negatives value for a class.
FP(x) is the False Positives value for a class.
FN(x) is the False Negatives value for a class.

Precision

Precision is a multi-class confusion matrix is the measure of the accuracy relative to the prediction of a specific class. It is calculated as the ratio of the True Positives of the class in question to the sum of its True Positives and False Positives.

For example, calculating the Precision of the Greyhound class:

Precision (G) = TP / (TP + FP)
= PGG / (PGG + (PGM + PGS))

Similarly, we can calculate the Precision of other classes.

Calculating the Precision of the Mastiff class:

Precision (M) = TP / (TP + FP)
= PMM / (PMM + (PMG + PMS))

Calculating the Precision of the Samoyed class:

Precision (S) = TP / (TP + FP)
= PSS / (PSS + (PSG + PSM))

True Positive Rate

The True Positive Rate (also known as Recall or Sensitivity) is calculated as the ratio of the True Positives of a specific class to the sum of its True Positives and False Negatives.

For example, calculating the True Positive Rate of the Greyhound class:

TPR (G) = TP / (TP + FN)
= PGG / (PGG + (PMG + PSG))

Similarly, we can calculate the True Positive Rate of other classes.

Calculating the True Positive Rate of the Mastiff class:

TPR (M) = TP / (TP + FN)
= PMM / (PMM + (PGM + PSM))

Calculating the True Positive Rate of the Samoyed class:

TPR (S) = TP / (TP + FN)
= PSS / (PSS + (PGS + PMS))

True Negative Rate

The True Negative Rate (also known as Specificity) is calculated as the ratio of the True Negatives of a specific class to the sum of its True Negatives and False Positives.

For example, calculating the True Negative Rate of the Greyhound class:

TNR (G) = TN / (TN + FP)
= (PMM + PSM + PMS + PSS) / ((PMM + PSM + PMS + PSS) + (PGM + PGS))

Similarly, we can calculate the True Negative Rate of other classes.

Calculating the True Negative Rate of the Mastiff class:

TNR (M) = TN / (TN + FP)
= (PGG + PSG + PGS + PSS) / ((PGG + PSG + PGS + PSS) + (PMG + PMS))

Calculating the True Negative Rate of the Samoyed class:

TNR (S) = TN / (TN + FP)
= (PGG + PMG + PGM + PMM) / ((PGG + PMG + PGM + PMM) + (PSG + PSM))

Phewww, that was a lot. 😅😅

Now, a quick example

Suppose we have the image below as the visualized confusion matrix for our classifier, we can use the information in the visualization and the metrics defined above to evaluate its performance.

From this confusion matrix, we can identify that:

The variable PGG and the True Positives of the Greyhound class is 250.

The variable PMM and the True Positives of the Mastiff class is 320.

The variable PSS and the True Positives of the Samoyed class is 180.

The variable PMG is 25.

The variable PSG is 18.

The variable PGM is 21.

The variable PSM is 24.

The variable PGS is 22.

The variable PMS is 12.

Using this information that we've "extracted", we can calculate the metrics mentioned earlier and thus evaluate the performance of the classifier.

True Negatives

TN (Greyhound) = PMM + PSM + PMS + PSS = 320 + 24 + 12 + 180 = 536

TN (Mastiff) = PGG + PSG + PGS + PSS = 250 + 18 + 22 + 180 = 470

TN (Samoyed) = PGG + PMG + PGM + PMM = 250 + 25 + 21 + 320 = 616

False Positives

FP (Greyhound) = PGM + PGS = 21 + 22 = 43

FP (Mastiff) = PMG + PMS = 25 + 12 = 37

FP (Samoyed) = PSG + PSM = 18 + 24 = 42

False Negatives

FN (Greyhound) = PMG + PSG = 25 + 18 = 43

FN (Mastiff) = PGM + PSM = 21 + 24 = 45

FN (Samoyed) = PGS + PMS = 22 + 12 = 34

True Positive Rate / Recall / Sensitivity

TPR (Greyhound) = TP / (TP + FN) = 250 / (250 + 43) = 250 / 293 = 0.8532423208 = 0.85

TPR (Mastiff) = TP / (TP + FN) = 320 / (320 + 45) = 320 / 365 = 0.8767123288 = 0.88

TPR (Samoyed) = TP / (TP + FN) = 180 / (180 + 34) = 180 / 214 = 0.8411214953 = 0.81

True Negative Rate / Specificity

TNR (Greyhound) = TN / (TN + FP) = 536 / (536 + 43) = 536 / 579 = 0.92573402417962 = 0.93

TNR (Mastiff) = TN / (TN + FP) = 470 / (470 + 37) = 470 / 507 = 0.9270216963 = 0.93

TNR (Samoyed) = TN / (TN + FP) = 616 / (616 + 42) = 616 / 658 = 0.9361702128 = 0.94

Precision

Precision (Greyhound) = TP / (TP + FP) = 250 / (250 + 43) = 250 / 293 = 0.8532423208 = 0.85

Therefore, the classifier has a precision of 0.85, which is 85%, in classifying images of Greyhounds.

Precision (Mastiff) = TP / (TP + FP) = 320 + (320 + 37) = 320 / 357 = 0.8963585434 = 0.90

Therefore, the classifier has a precision of 0.90, which is 90%, in classifying images of Mastiffs.

Precision (Samoyed) = TP / (TP + FP) = 180 / (180 + 42) = 180 / 222 = 0.8108108108 = 0.81

Therefore, the classifier has a precision of 0.81, which is 81%, in classifying images of Samoyeds.

Accuracy

AC = (TP(G) + TP(M) + TP(S) + TN(G) + TN(M) + TN(S)) / (TP(G) + TP(M) + TP(S) + TN(G) + TN(M) + TN(S) + FP(G) + FP(M) + FP(S) + FN(G) + FN(M) + FN(S))
= (250 + 320 + 180 + 536 + 470 + 616) / (250 + 320 + 180 + 536 + 470 + 616 + 43 + 37 + 42 + 43 + 45 + 34)
= 2372 / 2616
= 0.90672782874
= 0.90

Therefore, the classifier has a total accuracy of 0.90 which is 90%

How to generate a multi-class confusion matrix in Python

A multi-class confusion matrix is created in the same way as a 2-class confusion matrix. See the first part of this article.

Understanding the Confusion Matrix

Banso D. Wisdom — Mon, 22 Apr 2019 21:02:35 +0000

A confusion matrix is a table that describes the performance of a classifier/classification model. It contains information about the actual and prediction classifications done by the classifier and this information is used to evaluate the performance of the classifier.

Note that the confusion matrix is only used for classification tasks, and as such cannot be used in regression models or other non-classification models.

Before we go on, let's look at some terms.

Classifier: A classifier is basically an algorithm that uses "knowledge" gotten from training data to map input data to a particular category or class. Classifiers are either binary classifiers or multi-class/multi-categorical/multi-label/multi-output classifiers.
Training and test data: When building a classification model/classifier, datasets are split into training data and test data which have associated labels. A label is an expected output which is the category or class data belongs to.
Actual classifications: This is the expected output (labels) on the data.
Prediction classifications: This is the output given by the classifier for a particular input data.

An example: Let's say we have built a classifier to categorize an input image of a car as either a sedan or not, and we have an image in our dataset that has been labeled as a non-sedan but the classification model classifies as a sedan.
In this scenario, the actual classification is non-sedan while the prediction classification is sedan.

Types of Confusion Matrices

There are two types of confusion matrices:

2-class confusion matrix
Multi-class confusion matrix

2-Class Confusion Matrix

A 2-class as the name implies is a confusion matrix that describes the performance of a binary classification model. A 2-class matrix for the sedan classifier I described earlier can be visualized as such:

In this visualization, we have two sections which have been outlined. We have the predicted classifications section which contains two subsections for each of the classes and the actual classifications section which has two subsections for each of the classes.

If this is your first time seeing a confusion matrix, I know you must be wondering what all the variables in the table represent. It is quite simple actually, I will explain as simply as I can, but before I do it is important to know that these variables represent a number of predictions.

The variable a

The variable a falls under the Non-sedan sub-section in both the Actual and Predicted classification sections. This means a predictions were made that correctly classified an image of a non-sedan [as a non-sedan].

The variable b

The variable b falls under the Non-sedan sub-section in the Actual classification section and under the Sedan sub-section in the Predicted classification section. This means b predictions were made that incorrectly classified an image of a non-sedan as a sedan.

The variable c

The variable c falls under the Sedan sub-section in the Actual classification section and under the Non-sedan sub-section in the Predicted classification section. This means c predictions were made that incorrectly classified an image of a sedan as a non-sedan.

The variable d

The variable d falls under the Sedan sub-section in both the Actual and Predicted classification sections. This means d predictions were made that correctly classified an image of a sedan [as a sedan].

Easy peasy lemon squeezy. (I hope? 😅)

But wait, we're not done yet.......

Now we have our confusion matrix for our sedan classifier, but how does this help us ascertain our classifier's performance/efficiency?
To ascertain the performance of a classifier using the confusion matrix and the data it contains, there are some standard metrics that we can calculate [for] using the data(variables) in the confusion matrix.

Accuracy

Accuracy in a 2-Class confusion matrix is the ratio of the total number of correct predictions to the total number of predictions.
From our confusion matrix, we can see that a and d predictions were made that correctly classified the input image and b and c predictions were made that incorrectly classified the input image.

Therefore, accuracy can be calculated as:

Accuracy = (a + d) / (a + b + c + d)

Where, a + d is the total number of correct predictions and a + b + c + d is the total number of predictions made.

True positives, True negatives, False positives and False negative

With relation to our classifier and confusion matrix:

True positives (TP) are the number of predictions where an image of a sedan is correctly classified [as a sedan].
From our confusion matrix, the variable d is also the TP.

True negatives (TN) are the number of predictions where an image of a non-sedan is correctly classified [as a non-sedan].
From our confusion matrix, the variable a is also our TN.

False positives (FP) are the number of predictions where an image of a non-sedan is incorrectly classified as a sedan.
From our confusion matrix, the variable b is also our FP.

False negatives (FN) are the number of predictions where an image of a sedan is incorrectly classified as a non-sedan.
From our confusion matrix, the variable c is also our FN.

True Positive Rate

The true positive rate is a ratio of the true positives to the sum of the true positives and false negatives. It shows how often the classifier classifies an image of a sedan as a sedan.

Therefore, the true positive rate can be calculated as:

True Positive Rate = d / (c + d)
Where d is TP and c is FN

True positive rate is also known as recall or sensitivity

False Positive Rate

The false positive rate is a ratio of the false positives to the sum of the true negatives and false positives. It shows how often the classifier classifies an image of a non-sedan as a sedan.

Therefore, the false positive rate can be calculated as:

False Positive Rate = b / (a + b)
Where a is TN and b is FP

True Negative Rate

The true negative rate is a ratio of the true negatives to the sum of the true negatives and false positives. It shows how often the classifier classifies an image of a non-sedan as a non-sedan.

Therefore, the false positive rate can be calculated as:

True Negative Rate = a / (a + b)
Where a is TN and b is FP

The true negative rate is also known as specificity.

False Negative Rate

The false negative rate is a ratio of the false negatives to the sum of the false negatives and true positives. It shows how often the classifier classifies an image of a sedan as a non-sedan.

Therefore, the false positive rate can be calculated as:

False Negative Rate = c / (c + d)
Where d is TP and c is FN

Precision

The precision is a ratio of the true positives to the sum of the true positives and false positives. It shows how often the classifier classifies an input image as a sedan and it turns out to be correct.

It is calculated as:

Precision = d / (b + d)
Where d is TP and b is FP

An Example

Suppose we have the image below as the confusion matrix for our classifier, we can use the metrics defined above to evaluate its performance.

From the confusion matrix, we can see that:

4252 predictions were made that correctly classified a non-sedan [as a non-sedan]. Therefore, our variable a and the True Negative (TN) is 4252.

875 predictions were made that incorrectly classified a non-sedan as a sedan. Therefore, our variable b and the False Positive (FP) is 875.

421 predictions were made that incorrectly classified a sedan as a non-sedan. Therefore, our variable c and the False Negative (FN) is 421.

4706 predictions were made that correctly classified a sedan [as a sedan]. Therefore, our variable d and the True Positive (TP) is 4706

Using the data we've "extracted", we can calculate the aforementioned metrics and ascertain the performance of the classifier. We can already tell that the classifier performs well since the number of correct predictions is greater than the number of incorrect predictions.

Accuracy

Accuracy = (a + d) / (a + b + c + d)
= (4252 + 4706) / (4252 + 875 + 421 + 4706)
= (8958) / (10254)
= 0.8736102984201287
Accuracy = 0.87

Therefore the classifier has an accuracy of 0.87 which is 87%

True Positive Rate

TPR = TP / (TP + FN)
= 4706 / (4706 + 421)
= 4706 / 5127
= 0.917885703140238
TPR = 0.92

Therefore the classifier has a True Positive Rate of 0.92 which is 92%

False Positive Rate

FPR = FP / (FP + TN)
= 875 / (875 + 4252)
= 875 / 5127
= 0.1706651062999805
FPR = 0.17

Therefore the classifier has a False Positive Rate of 0.17 which is 17%

True Negative Rate

TNR = TN / (TN + FP)
= 4252 / (4252 + 875)
= 4252 / 5127
= 0.8293348937000195
TNR = 0.83

Therefore the classifier has a True Negative Rate of 0.83 which is 83%

False Negative Rate

FNR = FN / (FN + TP)
= 421 / (421 + 4706)
= 421 / 5127
= 0.082114296859762
FNR = 0.08

Therefore the classifier has a False Negative Rate of 0.08 which is 8%

Precision

Precision = TP / (TP + FP)
= 4706 / (4706 + 875)
= 4706 / 5581
= 0.8293348937000195
Precision = 0.83

Therefore the classifier has a Precision of 0.83 which is 83%

How to generate a confusion matrix using Python

import matplotlib.pylab as plt
import itertools
import numpy as np
from sklearn.metrics import confusion_matrix

def plot_confusion_matrix(cm, classes,normalize=False):
    plt.figure(figsize = (5,5))
    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
    plt.title('Confusion matrix')
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=90)
    plt.yticks(tick_marks, classes)
    if normalize:
        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]

    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, cm[i, j],
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")
    plt.tight_layout()
    plt.ylabel('Actual')
    plt.xlabel('Predicted')

dict_characters = {0: 'Non-sedan', 1: 'Sedan'}

y_pred = model.predict(test_data)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true = np.argmax(test_labels, axis=1)

confusion_mat = confusion_matrix(y_true, y_pred_classes)
plot_confusion_matrix(confusion_mat, classes = list(dict_characters.values()))

To generate a confusion matrix, we utilize numpy, matplotlib.pylab to visualize the matrix, the confusion_matrix function from the sklearn.metrics package to generate the confusion matrix, and itertools for looping/iteration.

First, we define a function plot_confusion_matrix that takes the generated confusion matrix and expected/possible classes as arguments and the uses matplotlib.pylab to visualize the confusion matrix.

In the snippet, we assume we have already have our trained model and training and test data with associated labels.

dict_characters is a dictionary of the two possible classes, in our case, "non-sedan" and "sedan".
y_pred is a numpy array of predictions done by the classifier on the test data
model is our trained classifier/algorithm
test_data is our test data
y_pred_classes is a numpy array of indices relative to y_pred which is the array of predictions done by the classifier on the test data.
y_true is a numpy array of indices relative to the actual/correct labels of the test_data.
test_labels is a list of labels of the test data.

Using the above, we use the confusion_matrix function from sklearn.metrics to generate the confusion matrix, passing in the correct values (y_true) and the estimated values returned by the classifier (y_pred_classes) and we store the generated confusion matrix in a variable confusion_mat.

We then pass the confusion matrix (confusion_mat) and a list of the values of our possible classes (dict_characters) as arguments to the plot_confusion_matrix function which then visualizes the confusion matrix.

In my next post, I [hopefully] would be writing on the multi-class confusion matrix.

A Quick Look at Constructable Stylesheets

Banso D. Wisdom — Fri, 05 Apr 2019 21:29:37 +0000

"Constructable Stylesheets". This might be the first time you're hearing of this and you must be thinking "what the flux is that?", and that's fine, that was my reaction when I first heard of it too.

What are Constructable Stylesheets?

Simply put, Constructable Stylesheets are a way to create and distribute reusable styles when working with the Shadow DOM.

What is the Shadow DOM?

To understand how Constructable Stylesheets work, we need to understand what the Shadow DOM is and to do that we need to understand what the DOM is.

The DOM which stands for Document Object Model is a representation of an HTML document, it is used in Javascript to modify a page's content and is also utilized by browsers to figure out what to render on a page.

The Shadow DOM is a DOM within "The DOM". It is a completely separate DOM tree from "The DOM" with its own elements and styling. It was created for the purpose of encapsulation and most applications of the Shadow DOM revolve around creating complex components/elements in such a way that the styling of these components/elements is unaffected by other style rules in "The DOM".
A good example of this is Ionic 4 UI components.

To better understand how the DOM and Shadow DOM works, here is an article What is the Shadow DOM by Ire Aderinokun.

Why Constructable Stylesheets?

"Why do we need a new way of creating stylesheets?" you might ask. I asked the same question too. As we all might know, we have always created/been able to create stylesheets on the fly using Javascript like this:



const style = document.createElement('style');

and obtain a reference to the underlying CssStyleSheet instance by accessing the sheet property.

This method works quite alright, but it has a few downsides, some of which are:

It can result in duplicate CSS code and thus cause CSS bloat.

What is CSS Bloat?

CSS bloat is unnecessarily repeated CSS code and while it directly doesn't affect your performance it indirectly affects your performance as having redundant selectors and rules increases your bundle size and makes your page heavier to load and slow to render.

It can lead to FOUC.

What is FOUC?

FOUC - Flash of Unstyled Content is a scenario where the content web page loads un-styled briefly then shortly after appears styled. This occurs when the browser renders the page before completely loading all the required assets.
FOUC can be caused by having duplicate CSS code (CSS bloat) which in turn causes a larger and heavier bundle which is slow to render.

The aforementioned problems are easily solved by using Constructable Stylesheets.

How to use Constructable Stylesheets

Creating a Stylesheet

To create a stylesheet according to the Constructable Stylesheets specification, we do by invoking the CSSStyleSheet() constructor.



const sheet = new CSSStyleSheet();

The resulting object, in this case, sheet has two methods that we can use to add and update stylesheet rules without the risk of FOUC. These methods both take a single argument which is a string of style rules.

These methods are:

replace(): This method allows the use of external references i.e. @import in addition to CSS rules and it returns a promise that resolves once any imports are loaded.



  sheet.replace('@import url("app.css"); p { color: #a1a1a1 }').then(sheet => {
      console.log('Imports added and styles added');
  }).catch(error => {
      console.error('Error adding styles: ', error)
  });

replaceSync(): This method doesn't allow @import, only CSS Rules.



  // this works
  sheet.replaceSync('p { color: #a1a1a1 }');

  // this throws an exception
  try {
      sheet.replaceSync('@import url("app.css"); p { color: #a1a1a1 }');
  } catch(error) => {
      console.error(error);
  }

Using a Constructed Stylesheet

After creating a stylesheet, we'd like to use it, of course. We use created stylesheets by using the adoptedStyleSheets property which Documents and Shadow DOMs possess.
This property lets us explicitly apply the styles we have defined in our Constructed Stylesheet to a DOM subtree by setting the value of this adoptedStyleSheets property to an array of stylesheets.



// applying the earlier created stylesheet to a document
document.adoptedStyleSheets = [sheet];

// creating an element and applying stylesheet to its shadow root
const el = document.createElement('div');
const shadowRoot = el.attachShadow({ mode: open });
shadowRoot.adoptedStyleSheets = [sheet];

We can also create new stylesheets and add them to the adoptedStyleSheets property.
Now normally, since the property is an array, using mutations like push() would be the way to go. However, in this case, it's not so.

This is because the adoptedStyleSheets property array is frozen and therefore in-place mutations like push() won't work.

When is an array said to be frozen?

A frozen array is an array which has been frozen as an object via the Object.freeze() method. The Object.freeze() method "freezes" an object which prevents new properties from being added to it, prevents the values of existing properties from being changed and also prevents the object's prototype from being changed.

What is an in-place mutation?

The term "in-place" is used to describe an algorithm that transforms the input given to it without using any additional data structure. While an algorithm that utilizes an additional data structure in transforming input is said to be out-of-place/not-in-place.

Consider the following methods, both to reverse the order of an array:

P.S: This is just for explanation purposes.



const reverseOutOfPlace = (input) => {
  const output = [];
  input.forEach((element, index) => {
    output[index] = input[input.length - (index + 1)];
  })
  return output;
}

const reverseInPlace = (input) => {
  const len = input.length;
  for(let i = 0; i <= Math.floor((len-2)/2); i++) {
    const temp = input[i];
    input[i] = input[len - 1 - i];
    input[len - 1 - i] = temp;
  }
  return input;
}

They both reverse the order of a given array, however, the reverseOutOfPlace method uses an additional array output to reverse the input while the reverseInPlace method doesn't use any additional arrays, as such the former is out-of-place while the latter is in-place.

Array [mutation] methods like pop and push are in-place because they don't use any additional arrays while others like concat and map are out-of-place because they use additional arrays in transforming the input array.

Since the adoptedStyleSheets property array is frozen and the values of its properties cannot be changed, the best way to add new stylesheets to the array is using concat() or the spread operator



const newSheet = new CSSStyleSheet();

newSheet.replaceSync('p { color: #eaeaea }');

// using concat

shadowRoot.adoptedStyleSheets = shadowRoot.adoptedStyleSheets.concat(newSheet);

// using the spread operator

shadowRoot.adoptedStyleSheets = [...shadowRoot.adoptedStyleSheets, newSheet]

What can I do with Constructable Stylesheets

Constructable Stylesheets has wide possibilities of usages, below are some of them:

Create shared CSS styles on the fly and apply them to the document or multiple Shadow roots without CSS bloat.
When a shared CSSStyleSheet has been applied to elements, any updates to it reflect on all the elements that it has been applied to. This can be used to implement hot replacement of styles within Shadow DOMs.
Change CSS custom properties on the fly for specific DOM subtrees.
Create a central theme that is used by/applied to several components.
As a direct interface to the browser's parser to preload stylesheets.

Here is a pen I made that shows most of what is in this post.

For more information on Constructable StyleSheets, check out these posts: Constructable Stylesheets: Seamless reusable styles and Constructable Stylesheet Objects.

P.S: At the time of writing this article, Constructable StyleSheets has only shipped to Chrome, so the aforementioned pen will work on only chromium-based browsers.

Machine Learning at A Glance

Banso D. Wisdom — Tue, 27 Nov 2018 09:51:50 +0000

Hi there! It's been a while since I last wrote anything. I've been really busy, so it's been difficult to write.

This article is one which I had drafted a while ago but I hadn't just gotten around to writing. It's "Machine Learning at a glance" and it aims to help demystify machine learning, make it as easy as possible to comprehend and serve as a beginner roadmap.

This article outlines stuff from my talk on the same topic at the North-Central Devfest of the Google Developer Group in Nigeria in 2017. I know, it's been a while since then, but this stuff is still relevant as I occasionally meet people who say they have interest in machine learning and artificial intelligence, but do not know how to go about it or what it entails. I hope this article helps provide some sort of insight.

Artificial Intelligence

Artificial intelligence (AI) has become a household term over the past couple of years, we see it been referred to and depicted in games, movies (remember J.A.R.V.I.S?) and in books, but what really is artificial intelligence?

AI is simply intelligence exhibited by/in machines, these machines are called intelligent machines. An intelligent machine is any device(from small devices like our smartphones to larger devices like TVs) that perceives its environment and takes action that maximizes it chances at success at some goal.

Simply put, an intelligent machine is a device that studies its environment, learns from it and adapts to changes in the environment by adjusting its actions in order to better perform specific tasks; tasks it was designed to accomplish.

Applications of Artificial Intelligence

We've all seen artificial intelligence been depicted in movies, games and books, but there are also real-world applications of artificial intelligence, some of which are:

Finance
Health care/Medicine
Customer service/Chatbots
Education
Transportation
Technology

AI of the past were limited to a few functions like error-reporting and all that basic stuff. AI of the near future is projected to be able to do much more complex stuff, and we are already seeing some of that in the present.
The question is "How do we develop AI to such a level? How do we build intelligent machines capable of complex stuff", the answer is machine learning.

Machine Learning

Compared to AI, the term "Machine learning" might not be so common or it might be, but most people don't have even the faintest idea of what it's about.

Machine learning (ML) is an approach to achieving Artificial Intelligence. That being said, we can say the goal is to develop intelligent machines and that machine learning is a way of achieving that goal.
ML deals with developing systems that learn without being explicitly told what to do, similar to how humans learn.

Traditional Programming vs Machine Learning

Traditional Programming

In traditional programming, we provide the rules and data as input and the algorithm provides us answers as output. Let me show a quick example, using simple interest.

We all know simple interest from math, yeah? And when starting out with programming, after writing the usually "hello world" program, simple arithmetic programs are usually the next thing to do; so this example should be straightforward.

Now, the formula for simple interest is (PRT)/100. Using the diagram above, we can analyse a program that calculates simple interest thus:

Data: The data provided as input would be the variables P, R and T.
Rules: The rules would be the formula SI = (PRT)/100
Answer: And the answer would be the variable SI

This is basically how traditional programming works.

Machine Learning

In machine learning, it's way different from traditional programming. Here, we provide the data and expected answers as input and the algorithm generates rules as output.
An example is a machine learning system that differentiates between real and counterfeit bank notes. Using the diagram above, we can analyse such a system thus:

Data: The data provided as input would be several thousand images of both counterfeit and real banknotes.
Answer: The answers provided as input would be labels on these images which specify whether or not a particular image is that of a real or a counterfeit banknote.
Rules: The rules would then be generated by the machine learning algorithm, these rules are more or less the algorithms understanding of how it can differentiate real banknotes from the counterfeit notes.

Why should we care about Machine Learning?

I often get asked questions like "Why should I care about machine learning? Why is it suddenly important? Why now?",
Here are a following reasons why we should care about machine learning and why it's "suddenly" important:

Data availability: There is a lot of data being generated right now, A LOT(big data sound familiar?). This data is generated by our smart devices, embedded systems and several other sources. There is so much data now than ever before and this data can be analysed to discover patterns, trends and associations that can be used to make intelligent decisions, so why don't we do that?
Computing power: Current hardware have enough computing power to analyse data. We have PCs with crazy hardware, we have phones with more computing power than the computers that took man to the moon.

Between the large amount of data and devices with sufficient computing power to analyse them, I believe there is no better time to care about machine learning.

The machine learning process

The machine learning process can be defined as a sequence of steps which are:

Data collection: This involves sourcing of data to be used as input. Data could be in different formats: XML, JSON, CSV, text files, images, etc and can be gotten from various sources.
Data preparation: This involves analyzing and filtering data based on the requirements of the machine learning system to be developed and removing poor, bad and unnecessary data. This also involves splitting the prepared data into training and test sets, the training set will be used to train the algorithm and the test set will be used for validation
Training: This is the part of the machine learning process where the algorithm is trained using the training set.
Evaluation: After training, the trained model evaluated using the test set.
Optimization: Based on the results of the evaluation, the model can be optimized to reduce margin of error and increase efficiency. Optimization might involve tweaking a few things in the algorithm, introducing a new variable to increase efficiency or changing the entire model/algorithm completely.

Machine learning algorithms

There are three major classes of machine learning algorithms, they are:

Supervised Learning.
Unsupervised Learning.
Reinforcement Learning.

Supervised Learning

Supervised Learning is a class of machine learning algorithms that are used to build predictive models. They are "predictive models" because their aim is to predict future outcome based on historic data.
In Supervised Learning, the desired output is already known and as such data is labelled and the machine learning models are given clear instructions on what they are to learn and how they are how to learn it.

There are two main tasks/problems in supervised learning, they are:

Classification: This is a machine learning task/problem that deals with classifying items into categories. For example, real and counterfeit banknotes, cats and dogs, etc.
Regression: This is a machine learning task/problem that deals with predicting real values such as weight, money, etc. For example, predicting the price of fuel in 2023, predicting the cost of a 30-inch pizza(a 30-inch pizza would be such a sight!), predicting the amount of rainfall in 2020, etc.

See here to read a little more on Supervised Learning

Unsupervised Learning

Unsupervised Learning is a class of machine learning algorithms that are used to build descriptive models. They are "descriptive models" because their aim is to determine and define structure and similarities from unstructured and unlabelled data.
In Unsupervised Learning, the desired output is not known and as such data is unlabelled and models are not told how to learn, but must do so entirely on their own.

The major task in unsupervised learning is Clustering; a machine learning task/problem that deals with determining structure in unlabelled data.

Reinforcement Learning

Reinforcement Learning is a class of machine learning algorithms that are used to build models that use trial and error to determine which actions yield the greatest rewards. The aim of these models and reinforcement learning is to maximize rewards.
Reinforcement learning models are mostly used but not restricted to robotics, gaming and navigation.

Other machine learning algorithms include:

Semi-supervised learning: This uses a small amount of labelled data and a large amount of unlabelled data.
Active learning: Here, the model interactively queries the user to obtain new knowledge.

Resources to get you started with Machine Learning

Here are a few resources to get you started with machine learning:

Google's Machine Learning Crash Course: Google, being one of the big players in machine learning has a machine learning crash course designed to teach the basics of machine learning.
Udacity Machine Learning Nanodegree: Udacity offers an in-depth machine learning nanodegree which takes you through machine learning fundamentals and principles via projects.
Kaggle: Kaggle is one of the largest communities of data scientists and machine learning engineers and enthusiasts. It provides you access to a lot of datasets and the opportunity to explore and build models, learn and also participate in machine learning and data science competitions.
scikit-learn: sci-kit learn is an open source machine library in Python. It provides simple and accessible tools for data analysis and building machine learning models. It has an easy learning and I recommend using it for beginner-level stuff.
Zindi: Zindi is an African community of data scientists and machine learning engineers and enthusiasts. Zindi provides access to data sets sourced from Africa as well as the opportunity to participate in data science competitions.

Now is the time to get involved in machine learning and I hope this gives an insightful overview of what machine learning is and helps you get started. Good luck, and keep on learning!

An Intro. To Supervised Learning: The Good, The Bad and The Ugly

Banso D. Wisdom — Sun, 01 Oct 2017 00:38:25 +0000

Hey there. How goes it? In this article, I'll be talking about Supervised Learning, its merits and demerits. Supervised learning is a class of learning algorithms, which is under Machine Learning.

Surely, in this day and age almost everybody has heard of and applies Machine Learning.

What is machine learning?

Machine learning, just as the name implies is when a machine/computer program learns. When then can we say a computer program learns? Just as humans learn from experience with a particular task, so do computer programs learn.
Computer programs are said to learn from experience with respect to a set of tasks while their performance at said tasks is measured if their performance improves with experience. Simply put: computer programs are said to learn if they get better at a particular task with time.

So, where can we see Machine Learning in action?

Machine learning is applied in several instances, some of these are:

Spam checkers.
News categorization on news sites.
E-Chess
Youtube (Playlist generation based on currently playing content).
E-commerce sites (Suggestion of similar items).
.. and many more examples.

Learning Algorithms

There are three basic types of learning algorithms:

Supervised learning.
Unsupervised learning.
Semi-supervised learning

Learning algorithms differ mainly by the the training.
For this article we'll be focusing on Supervised learning.

Supervised Learning

In supervised learning, the training data consists of a set of input data and correct responses (labels) to each data set. The aim here is for the algorithm to generalize such as to respond correctly to every possible input. Simply put: the algorithm should be able to give correct output to inputs not included in the training data. There are two main "problems" in Supervised learning: Classification and Regression problems.

Classification Problem

What this entails is taking the input data and deciding which class/category the input data belongs to based on the training data. This deals with instances when the expected output is a category, e.g red, blue, e.t.c.
For example: an algorithm that sorts vehicles by colour or by type.

Regression Problem

Regression deals with estimating/approximating the relationship between variables. It is used in instances when the expected output is a real value e.g. weight, currency, e.t.c
For example: an algorithm that determines/predicts the power consumption in a particular year for a particular region.

Now that we've gone through the basics, let's see the merits and demerits.

The Good

There is greater control over the system in supervised learning. For example, you can define how many classes you want to have in the system, you can define the classes in a specific way, you can also train the classifier in a way it distinguishes classes accurately.
After training there's necessarily no need to keep training data in memory.

The Bad and The Ugly

Training is time-consuming as it requires a lot of computation time. Classification is also time-consuming as well as tedious.
If you use examples which were not covered by the training data, you might not get a correct output(label).
It's limited in terms of scalability.
It requires a great deal of computational cost to get a near perfect system.

I hope this has been helpful. Thanks for reading. You can reach me on Twitter @overrideveloper . Cheers!

Securing Your ASP.NET Application

Banso D. Wisdom — Sat, 16 Sep 2017 23:53:17 +0000

Security is a pretty important topic in software development. When developing software it is easier to leave your application insecure and open to attacks than to take security measures. Sometimes, I am guilty of slacking off when it comes to security. ðŸ˜…ðŸ˜…

In this article, I'll be using the ASP.NET MVC template as the talking point. The MVC template is very weak/vulnerable, security-wise. One can say the template favors simplicity over security.

Here are a couple of tips on how to secure your ASP.NET MVC application

1. Hash passwords

I know this is sort of an obvious practice in software development. However, I still feel the need to mention it. Hashing passwords is a very crucial part of authentication, but quite an easy one to forget, especially if you're writing your own custom authentication code.

Also, choice of hashing algorithm is important. NEVER use MD5 to hash passwords, MD5 is super-easy to crack.ðŸ˜’ðŸ˜’

2. Use strong password validation logic

Try to make your password validation as 'strong' as possible. Below is my personal favourite when it comes to password validation.

UserManager.PasswordValidator = new PasswordValidator
{
    RequiredLength = 6,
    RequireNonLetterOrDigit = true,
    RequireDigit = true,
    RequireLowercase = true,
    RequireUppercase = true,
};

3. Brief authentication error messages

Make your authentication error messages as short as possible. For example, on login failure, your error message should read "username/password invalid" rather than specify which is invalid, because that'd give enough information to a potential hacker.

Also, in password reset, if the entered email doesn't exist in the system, rather than return an error message, display a success page.

4. Turn on custom errors

By default the template shows full stack trace of exceptions whenever an error occurs. This is very sensitive information that should be hidden. This can be done from the web.config file by adding the custom errors tag and setting its mode to on.

<system.web>
    <customErrors mode="On"></customErrors>
</system.web>

5. Secure your cookies!

By default, the template's cookies can be accessed by JavaScript from other sites. These cookies can also be sent unencrypted over the wire. This can be fixed by adding the httpcookies tag to the web.config file.

<system.web>
    <httpCookies httpOnlyCookies="true" requireSSL="false"/>
</system.web>

If you're using SSL on your site, then requireSSL should be set to true.

6. Get rid of needless headers!

By default the template sends a couple of HTTP headers with every request. These headers contain sensitive information such as the server type, ASP.NET version and MVC version. We can fix this by setting enableVersionHeader setting to false.

<system.web>
    <httpRuntime targetFramework="4.5.2" enableVersionHeader="false"/>
</system.web>

After doing this, we clear custom headers

<system.webServer>
    <httpProtocol>
        <customHeaders>
            <clear />
        </customHeaders>
    </httpProtocol>
</system.webServer>

7. Rename your cookies.

In the MVC template, there are three basic cookies: the Application cookie, the Antiforgery Token and the Session cookie. We should rename these cookies to make the type of server we're using unknown to the user.

Renaming the session cookie

<system.web>
    <sessionState cookieName="custom_name" />
</system.web>

Renaming the Antiforgery token

This is done in the Global.asax.cs file

protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
            //added line
            ConfigureAntiForgeryTokens();
            //end of added line
        }
//added method
private static void ConfigureAntiForgeryTokens()
{
    AntiForgeryConfig.CookieName = "custom_name";

    // AntiForgeryConfig.RequireSsl = true;
}
//end of added method

If your site will use Ssl, uncomment the last line.

Renaming the Application cookie

This is done in the Startup.Auth.cs file of the App_Start folder

public void ConfigureAuth(IAppBuilder app)
{
    app.UseCookieAuthentication(new CookieAuthenticationOptions
    {
        AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
        LoginPath = new PathString("/Account/Login"),
        CookieName = "custom_name"
    });
}

8. Disable tracing

<system.web>
  <trace enabled="true" localOnly="true"/>
</system.web>

9. Display 403 - Forbidden response as a 404

When you navigate to a directory in IIS and ASP.NET MVC, it causes a 403 - Forbidden response to be returned. This basically means that directory browsing is disabled. Directory browsing is a security risk, as it grants access to the web.config file with all your connection strings.
When directory browsing returns a 403, it poses a problem as it tells a potential attacker that you're using IIS and there actually is a folder there.
We fix this by replacing the 403 response with the standard 404.

First we add httpErrors to the web.config file.

<system.webServer>
  <!-- Custom error pages -->
  <httpErrors errorMode="Custom" existingResponse="Replace">
    <!-- Redirect IIS 403 Forbidden responses to the not found action method on error controller -->
    <error statusCode="403" subStatusCode="14" responseMode="ExecuteURL" path="/error/notfound" />
  </httpErrors>
</system.webServer>

Then we turn off IIS' default document handling. This stops IIS from returning the default document (Using whats called a courtesy redirect) when navigating to a folder e.g. navigating to â€˜/Folder’ which contains an index.html file will not return â€˜/Folder/index.html’. If it redirects to the default document, in the page url, it displays the directory's path to potential attackers and we wouldn't want that.

<system.webServer>
  <defaultDocument enabled="false"/>
</system.webServer>

Using the few tips above, you can make your ASP.NET Application more secure.ðŸ˜ Thanks for reading! ðŸ˜„ðŸ™‚

CORS in ASP.Net Web API

Banso D. Wisdom — Tue, 29 Aug 2017 14:08:16 +0000

What's a cross-origin http request?

This is a request made by a resource to a resource in a different domain, protocol, port to its own. For example, an HTML page at "http://domain1.com" makes a request to a resource at "http://domain2.com".

Why are we talking about this?

Well, this is sort of a 'big deal' because for security purposes, browsers restrict cross-origin requests intitiated from within scripts. So web apps can only make requests within it's domain. Kind of limits the apps, don't you think? This is where CORS comes in.

What is CORS?

CORS stands for Cross-Origin Resource Sharing. It is a standard that works by adding HTTP headers that allow servers to describe the set of origins that are permitted to read information using a web browser and the kind of request that are allowed.

Also, for HTTP request methods that can cause side-effects on server's data (usually HTTP requests other than GET), the specification mandates that browsers "preflight" the request i.e asking the server what methods are supported. It does this with an HTTP OPTIONS request method, and then, upon "approval" from the server, it send the actual HTTP request.

CORS in ASP.NET WEB API 2

In this article, I'll be showing how to enable CORS on an ASP.NET WEB API server.
For this article, I assume you already have a Web API project created.

Enabling CORS can be done in a couple of ways, which are as follows:

Enabling CORS per controller.

First, install the CORS package. In the Package Manager Console, type the following command: Install-Package Microsoft.AspNet.WebApi.Cors.

Navigate to the App_Start folder and open the WebApiConfig.cs file. Modify the WebApiConfig.Register to reflect the following changes:

using System.Web.Http;
namespace CORSWithWebAPI
{
    public static class WebApiConfig
    {
        public static void Register(HttpConfiguration config)
        {
            // Modification
            config.EnableCors();

            config.Routes.MapHttpRoute(
                name: "DefaultApi",
                routeTemplate: "api/{controller}/{id}",
                defaults: new { id = RouteParameter.Optional }
            );
        }
    }
}

Then, add the [EnableCors] attribute to the Controller class specifying origin, headers and methods. If you set [EnableCors] on the controller class, it applies to all the actions on the controller. To disable CORS for an action, add the [DisableCors] attribute to the action.

using System.Net.Http;
using System.Web.Http;
using System.Web.Http.Cors;

namespace CORSWithWebAPI.Controllers
{
    [EnableCors(origins: "http://client.domain", headers: "*", methods: "*")]
    public class SampleController : ApiController
    {
         public HttpResponseMessage Post() { ... }

        [DisableCors]
        public HttpResponseMessage PutItem(int id) { ... }   
    }
}

Setting the methods and headers to "*" means all headers are allowed and all methods are allowed. Specific methods and headers can also be set.

Enabling CORS per Action

This is similar to enabling per controller. Except that the [EnableCors] attribute is added to actions and not the controller.

public class SampleController : ApiController
{
    [EnableCors(origins: "http://client.domain", headers: "*", methods: "*")]
    public HttpResponseMessage GetSample(int id) { ... }
}

Enabling CORS Globally

To enable CORS for all Web API controllers, pass an EnableCorsAttribute instance to the EnableCors method in the WebApiConfig.cs file.

public static class WebApiConfig
{
    public static void Register(HttpConfiguration config)
    {
        var cors = new EnableCorsAttribute("client.domain", "*", "*");
        config.EnableCors(cors);
    }
}

CORS can also be enabled from the Web.Config file of the project

In the web.config file. Under the <system.webserver></system.webserver> section. Add the following changes:

<system.webServer>
    <handlers>
      <remove name="ExtensionlessUrlHandler-Integrated-4.0" />
      <remove name="OPTIONSVerbHandler" />
      <remove name="TRACEVerbHandler" />
      <add name="ExtensionlessUrlHandler-Integrated-4.0" path="*." verb="*" type="System.Web.Handlers.TransferRequestHandler" preCondition="integratedMode,runtimeVersionv4.0" />
    </handlers>

    <!-- New addition -->
    <httpProtocol>
    <customHeaders>
        <add name="Access-Control-Allow-Origin" value="*" />
        <add name="Access-Control-Allow-Credentials" value="true"/>
        <add name="Access-Control-Allow-Headers" value="Content-Type" />
        <add name="Access-Control-Allow-Methods" value="GET, POST, PUT, DELETE, OPTIONS" />
    </customHeaders>
    </httpProtocol>
    <!-- End of new addition -->
  </system.webServer>

This sets CORS globally for all controllers in your project.

Preflight request errors

I explained earlier what a preflight request is. In Web API, when making a preflight request from a script, more often than not, the preflight request returns a Http Error Code 405 even though everything is set right. This can be fixed by a little modification to the web.config and the Global.asax files.

In the web.config file:

<system.webServer>
    <handlers>
      <remove name="ExtensionlessUrlHandler-Integrated-4.0" />
      <remove name="OPTIONSVerbHandler" />
      <remove name="TRACEVerbHandler" />
      <add name="ExtensionlessUrlHandler-Integrated-4.0" path="*." verb="*" type="System.Web.Handlers.TransferRequestHandler" preCondition="integratedMode,runtimeVersionv4.0" />
      <!-- New addition -->      
      <add name="OPTIONSVerbHandler" path="*" verb="OPTIONS" modules="ProtocolSupportModule" requireAccess="None" responseBufferLimit="4194304" />  
      <!-- End of new addition -->  
    </handlers>
    <httpProtocol>
    <customHeaders>
        <add name="Access-Control-Allow-Origin" value="*" />
        <add name="Access-Control-Allow-Credentials" value="true"/>
        <add name="Access-Control-Allow-Headers" value="Content-Type" />
        <add name="Access-Control-Allow-Methods" value="GET, POST, PUT, DELETE, OPTIONS" />
    </customHeaders>
    </httpProtocol>
  </system.webServer>

And in the Global.asax file:

public class WebApiApplication : System.Web.HttpApplication
    {
        protected void Application_Start()
        {
            AreaRegistration.RegisterAllAreas();
            GlobalConfiguration.Configure(WebApiConfig.Register);
            FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
            RouteConfig.RegisterRoutes(RouteTable.Routes);
            BundleConfig.RegisterBundles(BundleTable.Bundles);
        }

        //Added code
        protected void Application_BeginRequest(object sender, EventArgs e)
        {
            if (HttpContext.Current.Request.HttpMethod == "OPTIONS")
            {
                HttpContext.Current.Response.Flush();
            }
        }
        //end of added code
    }

I hope this helps you enable CORS easily on your Web API project. Cheers!

Hi, I'm Banso D. Wisdom

Banso D. Wisdom — Thu, 06 Jul 2017 12:36:27 +0000

I have been coding for [1.5] years.

You can find me on GitHub as Overrideveloper

I live in [Abuja, Nigeria].

I work for [BizzDesk Global Solutions, Nigeria]

I mostly program in these languages: [C# and Angular.JS].

I am currently learning more about [Python and Django].

Nice to meet you.