Many times, when we are super-excited to predict using a fancy machine-learning algorithm, and we’re almost ready to apply our models to analyze and make classifications on the test data-set–– we don’t exactly know what features to pick. Often times, the # of features can range from tens to thousands, and it’s not exactly clear how to pick relevant features, and how many features we should select. Sometimes it’s a not a bad idea to combine features together, also known as feature engineering. A common example of this, you’ve probably heard in machine-learning –– is principal components analysis (PCA), where the data matrix X is factorized into its singular-value-decomposition (SVD) U*∑*V, where ∑ is a diagonal matrix with singular values, and the # of singular values you choose determines how many principal components. You can think of principal-components as a way to reduce the dimensions of your data-set. The awesome thing about PCA is that the new engineered features, or “principal-components”, are linear combinations of the original features. And that’s great! We love linear combinations, because it only involves addition and scalar-multiplication, and they’re not too hard to interpret. For example, if you did PCA on a dataset about house-price regression, and say you only selected 2 principal components. Then the first component, PC1, could be: c1*(# of bedrooms)+c2*(# sq.ft.). And PC2 could be something similar.

The limitation with principal components is, that the new features you make are *only* linear-combinations of some of the old ones. That means you can’t take advantage of making non-linear combinations of features. This is something neural networks are awesome at; they can create TONS of non-linear combinations/functions of features. But they have an even bigger problem: interpretability of the new features. The engineered features are basically hidden inside the weight-matrix multiplications between different layers of the network (which is just a composition of non-linear functions). And neural networks, with that extra non-linearity, can often be brittle and break under adversarial attacks, such as few-pixel attacks on convolutional neural networks, or tricking a neural network into mis-classifying a panda and a black square as a vulture –– weird, nonsense stuff like that.

So, what to do about features?? Well, if the ways we engineer new features are kinda limited, we could always just select a subset of the features we already have! But you need to be careful. There are many ways to do this, but not all of the are robust and consistent. For example, take random forests. It’s true that at the end of using the classifier, Python will output the relevant features with the feature_importances method of a random forest. But let’s think for a second: random forests work by training a bunch of decision trees, each one on a random subset of the training data. So if you kept repeating the RF model, you might get different feature-importances each time, and this is not robust or consistent. Wouldn’t it be confusing as a data scientist or ML engineer to see a different set of relevant features pop up each time? You clearly didn’t change the data set! So why should you trust different sets of “importance” features? The problem with this is that the “importance” features you’re picking, are dependent on the random-forest model itself––and even if RF’s have high accuracy, it also makes more sense to choose features based on the dataset alone, rather than including a heavy-duty model first.

The key to selecting features that are consistent, not confusing, and robust might be this: select features independently of your model. The relevant features you select should be relevant whether or not you use a neural network, an RF, logistic regression, or any other supervised learning model. This way, you don’t have to worry about the predictive power of your machine learning model while you’re trying to pick features at the same time, which be un-reliable.

So, how do you pick features that are independent of your model? Scikit-Learn has a few options. One of them which is my favorite is called mutual-information. It’s a important concept from probability-theory. Basically, it computes the dependence between your features-variables and your label-variable relative to the assumption that they’re independent. An easier way of saying that is it measure how much your class-labels depend on a specific feature.

So for example, say you’re predicting if someone has a tumor by looking at a bunch of feature columns in your dataset, like geometric-area, location, color-hue, etc. If you’re trying to choose relevant features to your prediction, you can use mutual-information to talk about how much each class-label depends on the geometric-area, location, and color-hue of the tumor. And this is a measurement gotten directly from the data; it never involved using a predictive model in the first place.

You can also use Sci-kit Learn’s chi-2, or “chi-squared”, to determine feature importance. What this does, is use a Chi-Squared test between the features and the label to determine which features are relevant to the label and which ones are independent of the label. You can think of this method as testing a “null hypothesis” H0: are the features independent of the classification label?To do this, you’d calculate a chi-squared statistic based on the data-table, get a p-value, and determine which features are independent or not. You then throw away the independent features (why? because they’re independent of the label according to your test, so they give no information) and keep the dependent ones.

This test is actually based on similar principles to the mutual-information calculation talked about above. However, chi2 does make the important assumptions that features in your dataset taking continuous values (say, 5.3, pi, sqrt(2), stuff like that) are normally distributed. Usually for big training-data sets this isn’t a problem, but for small training-data this assumption might be violated, so calculating mutual-information might be more reliable in those cases.

The basic point is this: mutual-information and chi-squared ways of feature-selecting are robust against the predictive model. Your predictive model might be wildly inaccurate, but the data you’ve collected is static in a table which never changes, so calculating your features without the model is more consistent.

Other ways of feature selecting include Recursive Feature Elimination (RFE), which uses a pre-fixed model (say, logistic/linear regression, or random forest) and tests almost all the subsets of features using the pre-fixed model, and decides which features are the best by seeing which subset of features gives the lowest accuracy error. (Technically, random forests use an additional method in Scikit Learn called feature_importance, but I won’t be getting into that here.) However, RFE does take a lot of time, because there are about 2-to-the-K subsets of features if you have K features, so it takes a long time to compute the model for each subset and get a score.

Another big reason I have against RFE and similar techniques is that it is fundamentally a feature-selection technique which is model-dependent. If your model is inaccurate, or overfits heavily, or does both and isn’t that interpretable by the user –– then the features you selected weren’t actually chosen by you, but by the model. So. the feature importance might not be an accurate representation of which features actually are predictive based just on the dataset.

So what can we take away from all this? Well, in the end, feature-selecting is extremely important if you don’t know how to interpret your engineered features using, say principal-component-analysis. However, when you do feature selection it’s just as important to take note about how you’re selecting your features, as well as computational time. Is your method taking too much time on the computer? Is your feature-selection based on using a particular model first? Ideally, you would want to feature-select regardless of what model you use, so in your Jupyter Notebook, you would ideally want to make a cell for feature-selection before the model –– something like this:

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import mutual_info_classif
# "mutual_info_classif" is the mutual-information way of selecting
# the K most dependent features based on the class-label

K = 3
selector = SelectKBest(mutual_info_classif, K)
X = new_df.iloc[:, :-1]
y = new_df.iloc[:, -1]
X_reduced = selector.fit_transform(X,y) 
                                   
features_selected = selector.get_support()

First, I did the feature selection (above).

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X_reduced, y, 
train_size=0.7)
# use logistic regression as a model
logreg = LogisticRegression(C=0.1, max_iter=1000, solver='lbfgs')
logreg.fit(X_train, y_train)

And then I trained the model (above)! :)

Help! How do I Feature Select? was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

Think critically about whether you actually need deep-learning in your pipeline.

Before you apply deep-learning to your customer data as an AI startup, think critically on the basic statistics of your customer data first–note down biases in the set–and ask yourself if deep-learning is really necessary to use on that set, or if you can use other statistics/ML methods.

Deep Learning, one of the “hottest” things in AI, has a way of seeping into popular culture as this mysterious, software that can make seemingly amazing classifications at human-level accuracy in Computer Vision, speech recognition, or play games like Go, recommend our favorite movies, and the like.

But deep learning has crucial pitfalls, when it drives cars that sadly, more than once, have injured or killed their drivers or pedestrians because of silly image-recognition mistakes. Or, when deep learning is used for face-recognition ––something that clearly has adverse effects on people of color, LGBT, and other marginalized groups –– and if deep learning’s face-prediction is used by institutions of power with a history of racism, LGBT-phobia, and tossed back and forth between private companies and governments –– deep-learning’s pitfalls become frighteningly magnified. Another example is when Facebook’s deep-learning neural translation machine led to the illegal arrest of a Palestinian man because of a post he made, at the end of 2017. If you think that these are “just unavoidable errors” made by an “intelligent system”, you’re clearly missing the point. Deep learning is really just a statistical correlation tool, and this connects to the title of this piece.

In the picture above of a artificial neural network, since there’s only 1 hidden layer, this neural network is considered shallow. If you insert at least two hidden layers or more, it’s considered a “deep” neural network. That’s all there is to it about the “deep” part of deep-learning.

The “deep” in deep-learning does not stand for deep, abstract understanding. It does not understand abstract concepts as humans do.

The “deep” simply means that the networks are deep in terms of length. Here’s an article from The Atlantic: Technology showing that while Google Translate uses deep-learning it its neural-translation, the AI system, again makes silly translation mistakes compared with human standards.

Now, how about the “learning” part of deep-learning? Surely it has to imitate human learning capabilities because the structure is designed like neurons in the brain!

NOPE. Think about it: if deep learning imitated human learning so well that it could pass the Turing test (a human would be fooled by a deep-learning system), there wouldn’t be an article in Nature detailing how deep-learning systems have made silly mistakes by human standards. And remember, if deep-learning is supposed to be like human learning, we should judge it by human standards. And one of the pioneers of deep-learning, Geoffrey Hinton, states he’s ‘deeply suspicious’ of neural nets as a way to explain human or Artificial General intelligence.

Here’s what deep-learning does: it approximates a function, a mapping. For example: if you had a database of patient health records, and you had to predict if the patient should receive treatment A or treatment B based on some training-set, you could train a deep-learning net on the set. What it would do, is approximate a direct mapping from patient record x to the treatment. Bear with me, I’m gonna borrow some math notation for a sec.

Say that X = patient records, and Y = {treatment A, treatment B}. Usually, the way labels are coded in machine learning is 0's and 1’s so Y = {1, 0}.

Now, what does a deep-learning network do? It just approximates a function f mapping X to Y. So it tries very hard, sometimes using thousands to millions of parameters — knobs and dials, to approximate a smooth function f(X) = Y.

How does it do this approximation though? Well, since f is often very complicated, it has to use an iterative algorithm. Neural networks use something called a “cost function” to find f(x). By minimizing the errors between what it predicts and the actual value, neural networks can approximate the mapping through an algorithm called “back-propagation”. (For folks who know the chain-rule for derivatives from calculus, back-propagation in neural nets is literally just the chain-rule applied to a big composition of smaller linear and nonlinear activation functions.) Don’t believe me? Check out this amazing visual video by Grant Sanderson (Youtube Channel 3b1b) explaining neural networks with the math included.

So that’s it! “Learning” in a neural network is simply an algorithm called back-propagation, used to minimize a cost function, which is used to approximate some complicated function between inputs and outputs. Is this what human learning and intelligence is? I hardly think so.

Why is this important? Well, a large number of startups that use AI in their software products love to use deep-learning as part of their toolkit to show how awesome the predictive power of their app-products (or other products are). And for sure, the idea of deep-learning sells hard. Of course it does! If a startup could claim to re-create human intelligence in a certain area (speech-recognition, computer vision) or at least claim to get on par with human-recognition in those areas, they would have unimaginable influence in the tech area. AI after all, is the golden treasure everyone in tech is seeking.

But beneath the icing of deep-learning, exists huge amounts of data collected in order to power that software. Function approximation is a very hard problem, and it often works only when you have a ton of data points. That’s one fundamental reason why companies like Google, Facebook, and Amazon can use deep learning: they’re basically oceans of data collecting data points like raindrops collecting into a basin. And since they are tech titans, they have power to use complex deep-learning models which could be wildly inaccurate in the real world –– and power to sell them as government contracts, or contracts with other companies that control the products we buy, the surveillance we live under, and the constant oppression through technology that marginalized people live through.

I’m not saying that if you’re thinking of starting an AI business that you can’t use deep-learning. Of course you can; there are hundreds of pre-trained deep neural network models downloadable from the Web. But you should use them critically. Think about the overall statistics of the data you’ve collected before you apply deep-learning to them. Don’t simply apply deep-learning, thinking that it’s going to unveil complex relationships between the variables you’re collecting data on. Deep-learning is a black-box, but you don’t have to use it like that. Understand the biases in your dataset; understand and note down social inequities that exist in your dataset; chances are, they exist already. Why? Because your dataset is like a (biased) random sample from the population of the world, and so it will reflect systems of discrimination and bias in our current society.

Think of deep learning as a screwdriver in a toolkit. Maybe it might work for some tasks, but for many, many tasks, it simply won’t work by itself, and trying to brute force it into problems it can’t solve fast enough as an efficient interpretable tool, might as well be a waste of time, money and could potentially risk actual human lives.

Don’t Forget what ‘Deep’ & ‘Learning’ Actually Mean was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

Interpretable-AI: Use-Case with Health Data

Disclaimer: to best understand the context for this article, it would be helpful to read my previous article on Interpretable-AI. It would also be helpful if you’ve coded Logistic Regression in Python before, since I mention it in my code.

In my previous article on Interpretable AI, I mentioned that advanced supervised learning algorithms such as Logistic Regression and Neural Networks (and its variants, such as Convolutional Neural Networks and Recurrent Neural Nets, for instance) are hard to interpret. Neural networks especially, part of deep learning, can produce amazing accuracies, but exactly how the algorithm produces its classification is poorly understood to the programmer and the users. Part of the reason why is that neural nets and logistic regression work hard to create a direct relationship to their predictions, but that comes at a expense: interpretability.

I mentioned previously that another way to understand the problem of classification is with Bayes’ Theorem for inference between two hypotheses we have — H1 (class label 1) and H2 (class label 0). For reference here’s the equation:

In today’s use-case, I’ll be applying this inference framework to the Hepatocellular Carcinoma Dataset on UC Irvine’s Machine Learning Repository. The dataset consists of 165 patients treated at the University of Madrid, and almost 50 individual features/measurements on each patient. The category labels indicate if the patient survived the carcinoma (1) or if they sadly couldn’t (0).

Let’s get started! First, we need to import the relevant packages. We’ll be importing more libraries as the code goes along. Since the dataset and code is long, this is my GitHub repo with the full code. I’ll be posting snippets here.

# First, we read in the file and import packages
import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import confusion_matrix as cmatrix 

hcc_data = pd.read_csv('/Users/rabeya/Carcinoma_Classification_data/hcc.csv')

Next, after we load in the data, we use an algorithm from Miriam Santos’ original paper on the HCC dataset utilizing “HEOM-distance” to fill in all the missing values labeled with a “?”. This “HEOM-distance” algorithm takes each patient record and fills in the missing value based on the patient-records “closest” to it; the notion of “close”, as you guessed, is based on the HEOM-distance. Since this algorithm has many lines I direct you to my Github repo for that. The filled-in dataset was named new_df.

Once I finished filling in the missing values, I needed to balance the labels. Label imbalance is a huge problem in machine-learning, due to bias in collection or missing values, the ratio of records with label 1 vs. label 2 might not be 50%:50%. In fact, in the HCC dataset, the ratio of patient-life to patient-death records is 62%:38%, so we need to balance the records. One way of doing this is called “artificial oversampling”, where we create artificially new data records for the smaller-class that are close to the original records. This over-sampling method is called “SMOTE” and the code is below.

from imblearn.over_sampling import SMOTE
sme = SMOTE(random_state=10)

#features
features = new_df.columns
# transform the dataset
X_matrix = new_df[features[:-1]].values
y_matrix = new_df[features[-1]].values
X_trans, y_trans = sme.fit_resample(X_matrix, y_matrix)

transformed_df = pd.DataFrame(X_trans, columns=features[:-1])
transformed_df['Class'] = y_trans

Now that we’ve transformed the dataset and balanced the classes (there are 102 patient-life and patient-death samples), we’re ready to build our generative classifier! (Our balanced HCC data-set is called transformed_df in the next sections.)

Before creating any models, we cut down the # of features in our dataset. The original one has 49 individual features/for each patient and that’s too much to think about! So instead, we’re cutting it down to the “best” 10 features using something in statistics called mutual-information.

First I fit a logistic-regression as a test model case to the training and test data. I split the training and test set into: 65% to training set, and 35% to test-set. This isn’t standard, but I did this since our entire set has only 200 records, so data must be used sparingly.

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import mutual_info_classif

K = 10
selector = SelectKBest(mutual_info_classif, k=K)
X = transformed_df.iloc[:, :-1]
y = transformed_df.iloc[:, -1]
X_reduced = selector.fit_transform(X,y)

# use logistic regression as a test case model
logreg = LogisticRegression(C=1.5, max_iter=1000, solver='lbfgs')
logreg.fit(X_train, y_train)

Using logistic regression on unseen data, the prediction accuracies were: true-positives— 36%; true-negatives— 30%; false-positives — 22%; false-negatives — 12%. Logistic regression doesn’t do great at prediction with this small of a dataset, and the FPR at 22% is dangerous to use for future predictions since 1 out of 5 future new HCC-patients would be predicted to survive, while their actual chance of surviving would be low. This poor predictive power isn’t surprising, because we only gave ~130 records for the model to train on.

There are many solutions to take from here: 1) to collect more data and dump it in, but HCC data doesn’t come by easily. 2) to use more parameters/weights, such as a neural network model for small-data. But as we discussed earlier, neural networks are hardly interpretable. The solution I took was to change the perspective of the prediction entirely, and to use generative models instead. As I mentioned, a generative model can help us calculate how probable data points under the assumption that they belong to different categories, and this probabilistic perspective is especially useful for small data.

Finally, we can create our generative models. The first type is called Gaussian Mixture Model (GMM), where a bunch of separate Gaussian models (called “components”) are tied together to create one big generative model. We separate our training data based on whether the patient survived or died from the carcinoma –– and then fit the models. In order to fit the models, we can’t just choose one # of components. Instead, I trained 64 models (the computer can perform this faster than you think) and the models are optimized using the Expectation-Maximization (EM) algorithm. The EM algorithm is a few decades old but is used frequently to find Gaussian mixtures.

I then picked the optimal numbers 22 and 21 based on a statistical measurement called the Akaike Information Criteria (AIC). It basically compares how accurate the density model is vs. how complex it is, and tries to walk the balance between overfitting and underfitting the model.

from sklearn.mixture import GaussianMixture as GMM
M = 64
# so M models to train
n_components = np.arange(2, M, 1)
 
life_models = [GMM(n, covariance_type='full', random_state=5) for n in n_components]

death_models = [GMM(n, covariance_type='full', random_state=7) for n in n_components]

life_aics = [model.fit(X_train_life).aic(X_train_life) for model in life_models]

death_aics = [model.fit(X_train_death).aic(X_train_death) for model in death_models]

gmm_life = GMM(22, covariance_type='tied',tol=1e-4, random_state=5)
gmm_life.fit(X_train_life)

gmm_death = GMM(21, covariance_type='tied',tol=1e-4, random_state=7)
gmm_death.fit(X_train_death)

And the accuracies on using the Gaussian Mixture models on unseen data were: 35% true-negative, 12% false-positive, 15% false-negative, and 37% true-positive. What an improvement in the false-positive rate over logistic regression! We can actually do even better on the false-positive rate by using a variant of the Gaussian Mixture model on steroids: Kernel Density Estimation (KDE). It definitely sounds like something out of AI sci-fi, but it works on the same principles!

from sklearn.neighbors import KernelDensity

kde_life = KernelDensity(bandwidth=0.1).fit(X_train_life)
kde_death = KernelDensity(bandwidth=0.1).fit(X_train_death)

log_density_life = kde_life.score_samples(X_test)
log_density_death = kde_death.score_samples(X_test)

And when we use the KDE method on unseen data, our prediction accuracies are: 44% true-negative, 8% false-positive, 2% false-negative, and 46% true-positive. Having been trained on only 130 records, KDE did an amazing job on its predictive power. (Something to keep in mind for GMM and KDE by the way, is overfitting the density model to the training data. I’ll explore this in a future article.)

OK, so this is all well and good, but how do we interpret the density model? Explainability is important. Well, if a new data-point patient Y from the test set came in, the machine could explain its prediction like this: “Since the class-labels (1=Survival, 0=Death) are balanced, my prior-ratio is equal to 1. Therefore, I base my decision only on the density likelihood models I calculated from training on the previous ~130 training records. From my survival-likelihood model, the log-likelihood of Y if I assume it belongs to class 1 is p1. And from my death-likelihood model, the log-likelihood of Y if I assume it belongs to class 0 is p2. Since I calculated that, say, (p1-p2) >0, this means that the probability patient-Y’s data record could’ve been generated — assuming it belongs to Class 1–– is greater than that of Class 0. Therefore, I classify patient Y survives carcinoma based on their 10 ‘best’ calculated features.” And this is what that code actually looks like:

delta = np.subtract(log_density_life, log_density_death)
# this is the difference in likelihoods under the hypothesis  assumptions (H1: label=1, H2: label=0)

kde_predictions = np.asarray([1 if x > 0 else 0 for x in delta])

Of course, the machine can’t talk to us, but I believe that is how we can understand the machine-learning model’s decisions. See how much more interpretable that was than say, using neural networks or logistic regression?

But not just that. Say that we had a larger dataset like this that wasn’t balanced. We could factor in the proportions of survival and death labels in the prior-ratio of Bayes’ Inference formula. And if we calculated the sam likelihood density models, and found that the prediction for a new test point was wrong, we could potentially revise the model. Either we could revise our prior probabilities of the class labels, or we could revise the likelihood models. How? By using a Bayesian framework on the likelihood models themselves. This could be done dynamically in a probabilistic-programming language such as PYMC3, for instance.

I hope that these results used on healthcare data provide an avenue toward using density estimation not just for clustering customer patterns, but deploying them for predictive power as we did in this project. I will point out that one feature the experimenters didn’t factor in was race/ethnicity. I can understand that since the dataset was collected in Spain, race would be pretty homogeneous. But ignoring race in data-collection, and not critically thinking about what other factors could be connected to that such as socio-economic class and access to healthcare, is a very risky and dangerous thing to do. But hopefully I’ll be able to find more HCC-datasets (or similar ones) that do take those factors into account as well.

See you all soon! :)

Explainable-AI: Use-Case #1 was originally published in TDS Archive on Medium, where people are continuing the conversation by highlighting and responding to this story.

Interpretable-AI: Where Supervised Learning Might Fail

Disclaimer: I’ll be briefly mentioning logistic-regression and basic feed-forward neural networks, so its helpful to have programmed with those 2 models before reading this piece.

OK — before machine learning folks come running after me after reading the title, I’m not talking about linear regression, for example. Yes, in linear regression, you can use the R-squared (or adjusted R-squared statistic) to talk about explained variance, and since linear regression only involves addition between independent variables (or predictors), they’re pretty interpretable. If you were doing a linear regression to predict, say the price of a car Car_Price, based on the number of seats, mileage, maximum-speed, and battery life, your linear model could be –– say Car_Price = c1*Seats + c2*Mileage + c3*Speed + c4*Battery_Power –– the fact that variables are only added makes it pretty interpretable. But when it comes to more complex prediction models like Logistic Regression and neural networks, everything about the predictors (or called “features” in ML) becomes more confusing. And logistic-regression & neural networks fall under supervised learning, because they basically just estimate a complicated black-box function from data -> labels.

People use logistic regression to predict whether something is true or not; for example, if patient X has a disease or not. It’s an example of a nonlinear classifier, because instead of just adding the features together, the features are mapped through the nonlinear sigmoid function, which squishes all inputs into the range between 0 and 1, since logistic regression is supposed to represent a probability. (Technically, if you search logistic-regression on Wikipedia, the “decision boundary” is linear, but that’s not the point.) TO me at least, logistic-regression already seems a bit less interpretable than linear-regression because of the nonlinear part. And neural networks are logistic regression chained together! (It’s a rough analogy, but it helps explain a point.) Neural nets, are by definition, made to be nonlinear so it would find non-linear connections between features and be a better predictor for say, image recognition –– why? Because the pixels are considered features, and the pixels making up a recognizable image are related in a non-linear way since images are complex.

But neural networks are often described as an unexplainable black box, and you do NOT want a neural network making important decisions about employment, loans, health-data, and so on if you can’t explain the reasons for the model’s decision. And given at least a. few self-driving fatal car accidents whose software runs on deep learning, a neural network’s decisions that led to a injury or death can’t even be explained in a principled way!

Neural networks are based on the idea of approximating functions, or mappings, between data and its label (example: image of a cat, cat-label). But in the 1989 original paper proving that neural networks can do this, the author, Cybenko, stated at the end: “At this point, we can only say that the majority of [mapping/function] approximation problems will require astronomical numbers of terms [neural nodes].” So while neural networks can create any function mapping between, say images (or predicting the next-word, with recurrent nets), they often have to have hundreds-of-thousands to millions of parameters (also called “weights”, same as “terms” that Cybenko says), with no principled way of interpreting and explaining the nonlinear connections. And human brains don’t need to see thousands of examples to generalize as neural nets do. For example, AlexNet, a famous neural network trained to classify cats, houses, cars, and real-life objects, has 60 million parameters, and had to be trained on 15 million images with almost 700 images for each label. And it sucked up an immense computational energy with multiple GPUs –– technologies that mostly large companies and research groups with tons of money have access to.

Personally, I believe that AI could use a dose of two things to make itself interpretable: inference, and unsupervised learning. Why? Well, I believe it comes down to the following equation:

This is Bayes’ Theorem, but with 2 hypothesis. Basically it says that the belief we give to hypothesis 1 over hypothesis 2 after seeing data, is just the product of how likely the data is assuming our hypotheses, times what we thought about the hypotheses before seeing the data. There’s evidence our brain computes probabilistic inference subconsciously in a similar way. But where does unsupervised learning play in, you say? Well, precisely in the “likelihood” piece of the equation. If you’ve heard of unsupervised learning related to “clustering”, or “finding patters in data without labels” –– that’s all true. But unsupervised learning is fundamentally about density-estimation, a fancy of way of saying “data description”. Density estimation gives us more power than just clustering. It can generate new data all on its own! And crucially, if we can use it to generate new data, then assuming either hypothesis, we can compare the distribution of generated data, to what we see in our test data. And if the test data is more likely to be generated with our estimated density by assuming Hypothesis 1 over 2, we can decide to choose one over the other. That kind of decision, I believe at least, is explainable and understandable because human brains are already wired to understand likelihood and reason with uncertainty. Generating new data in our mind is an important part of human intelligence –– so it should definitely be a key part of Interpretable-AI.

In my next article, I’ll be going over a use case of this. I’ll be analyzing the “Hepatocellular Carcinoma” dataset from the free online UCI Learning Repository , and show the code and results for classifying whether a patient with certain medical features survives or dies from the carcinoma. We’ll get to see differences in interpretability using 1) logistic-regression model to predict survival, and 2) a unsupervised, generative model, like above, to predict survival. See you then!

EDIT: My follow-up article, “Interpretable-AI: Use-Case with Health Data” is out on my Medium profile now! Any readers here who finished this piece, feel free to check it out!

Feel free to contact me at my LinkedIn!

References:

1. G, Sybenko, (1989). Approximation by Superpositions of a Sigmoidal Function
2. G. Marcus, (2017). Deep Learning: A Critical Appraisal
3. Pitkow, X., & Angelaki, D. E. (2017). Inference in the Brain: Statistics Flowing in Redundant Population Codes. Neuron, 94(5), 943–953.

Explainable-AI: Where Supervised Learning Can Falter was originally published in The Startup on Medium, where people are continuing the conversation by highlighting and responding to this story.