Now, Bengio says deep learning needs to be fixed. He believes it won’t realize its full potential, and won’t deliver a true AI revolution, until it can go beyond pattern recognition and learn more about cause and effect. In other words, he says, deep learning needs to start asking why things happen.
When we look at observational metrics, our Machine Learning models are doing great predicting a certain outcome given a treatment, but they are good exactly at that and not at the counterfactual – what would have been the outcome given no treatment
The book is divided in three parts of increasing difficulty: Part I is about causal inference without models (i.e., nonparametric identification of causal effects), Part II is about causal inference with models (i.e., estimation of causal effects with parametric models), and Part III is about causal inference from complex longitudinal data (i.e., estimation of causal effects of time-varying treatments).
Here are the top four reasons of why I think it’s a great book:
Detailed introduction to the key concepts including many examples
The first four chapters (a definition of causal effect, randomised experiments, observational studies and effect modification) cover key concepts such as potential outcomes (the outcome variable that would have been observed under a certain treatment value), individual and average causal effects, randomisation, identifiability conditions, exchangeability, positivity and consistency. You will get to know Zeus’s extended family, with many examples covering their various health conditions and treatment options. As an example, table 1.1 shows the counterfactual outcomes (die or not) under both treatment (a = 1 a heart transplant) and no treatment (a = 0). Providing practical examples along with the definition helps cement the learning by identifying the key attributes associated with the concept.
Starting from the introduction, the authors are quite clear about their goals
Importantly, this is not a philosophy book. We remain agnostic about metaphysical concepts like causality and cause. Rather, we focus on the identification and estimation of causal effects in populations, that is, numerical quantities that measure changes in the distribution of an outcome under different interventions. For example, we discuss how to estimate in patients with serious heart failure if they received a heart transplant versus if they did not receive a heart transplant. Our main goal is to help decision makers make better decisions
INTRODUCTION: TOWARDS LESS CASUAL CAUSAL INFERENCES
On top of it, the book comes with a large number of code example in both R and Python, covering the first two part including chapters 11-17. It would be great to see additional code examples covering part three (causal inference from complex longitudinal data).
You should start with reading the book, and on parallel fire-up
and start playing with the code
The validity of causal inferences models
The authors discuss a large number of non-parametric and parametric techniques and algorithms to calculate causal effects. But they keep reminding us that all of these techniques rely on untestable assumptions and on expert knowledge. As an example:
Unfortunately, no matter how many variables are included in L, there is no way to test that the assumption (conditional exchangeability) is correct, which makes causal inference from observational data a risky task. The validity of causal inferences requires that the investigators’ expert knowledge is correct
Causal inference generally requires expert knowledge and untestable assumptions about the causal network linking treatment, outcome, and other variables.
A (geeky) sense of humor
Technical books tend to be concise and dry, telling an anecdote or adding a joke can make difficult content more enjoyable and understandable.
As an example, when discussing the potential outcomes of the heart transplant treatment in Zeus’s extended family, here is how the authors introduced the issue of sampling variability:
At this point you could complain that our procedure to compute effect measures is somewhat implausible. Not only did we ignore the well known fact that the immortal Zeus cannot die, but more to the point – our population in Table 1.1 had only 20 individuals.
As another example, chapter 7 introduces the topic of confounding variables using an observational study which is designed to answer the causal question “does one’s looking up to the sky make other pedestrians look up too?”. The plot develops and new details are being shared in chapters 8 (selection bias), chapter 9 (measurement bias) and chapter 10 (random variability), till the authors announce the following
Do not worry. No more chapter introductions around the effect of your looking up on other people’s looking up. We squeezed that example well beyond what seemed possible
I hope that you will find this book useful and that you will enjoy learning about Causal Inference as much as I did!
ImageMagick® is used to create, edit, compose, or convert bitmap images. It can read and write images in a variety of formats (over 200) including PNG, JPEG, GIF, HEIC, TIFF, DPX, EXR, WebP, Postscript, PDF, and SVG. Use ImageMagick to resize, flip, mirror, rotate, distort, shear and transform images, adjust image colors, apply various special effects, or draw text, lines, polygons, ellipses and Bézier curves.
Wand is a ctypes-based simple ImageMagick binding for Python, so go through the step-by-step guide on how to install it.
Let’s start by installing ImageMagic:
brew install imagemagick@6
Next, create a symbolic link, with the following command (replace <your specific 6 version> with your specific version):
ln -s /usr/local/Cellar/imagemagick@6/<your specific 6 version>/lib/libMagickWand-6.Q16.dylib /usr/local/lib/libMagickWand.dylib
It seems that ghostscript is not installed by default, so let’s install it:
brew install ghostscript
Now we will need to create a soft link to /usr/bin, but /usr/bin/ in OS X 10.11+ is protected.
Just follow these steps:
1. Reboot to Recovery Mode. Reboot and hold “Cmd + R” after start sound.
2. In Recovery Mode go to Utilities -> Terminal.
3. Run: csrutil disable
4. Reboot in Normal Mode.
5. Do the “sudo ln -s /usr/local/bin/gs /usr/bin/gs” in terminal.
6. Do the 1 and 2 step. In terminal enable back csrutil by run: csrutil enable
I have two time series and I want to find the lag that results in maximum correlation between the two time series. The basic problem we’re considering is the description and modeling of the relationship between these two time series.
In signal processing, cross-correlation is a measure of similarity of two series as a function of the lag of one relative to the other. This is also known as a sliding dot product or sliding inner-product.
In the relationship between two time series (yt and xt), the series yt may be related to past lags of the x-series. The sample cross correlation function (CCF) is helpful for identifying lags of the x-variable that might be useful predictors of yt.
In R, the sample CCF is defined as the set of sample correlations between xt+h and yt for h = 0, ±1, ±2, ±3, and so on.
A negative value for h is a correlation between the x-variable at a time before t and the y-variable at time t. For instance, consider h = −2. The CCF value would give the correlation between xt-2 and yt.
For example, let’s start with the first series, y1:
x <- seq(0,2*pi,pi/100)
#  201
y1 <- sin(x)
plot(x,y1,type="l", col = "green")
Adding series y2, with a shift of pi/2:
y2 <- sin(x+pi/2)
Applying the cross correlation function (cff)
cv <- ccf(x = y1, y = y2, lag.max = 100, type = c("correlation"),plot = TRUE)
The maximal correlation is calculated at a positive shift of the y1 series:
cor = cv$acf[,,1]
lag = cv$lag[,,1]
res = data.frame(cor,lag)
res_max = res[which.max(res$cor),]$lag
#  44
Which means that maximal correlation between series y1 and series y2 is calculated between y1t+44 and y2t
The shell path for a user in OSX is a set of locations in the filing system whereby the user can use certain applications, commands and programs without the need to specify the full path to that command or program in the Terminal. This will work in all OSX operating systems.
You can find out whats in your path by launching Terminal in Applications/Utilities and entering:
Adding in a Permanent Location
To make the new path stick permanently you need to create a .bash_profile file in your home directory and set the path there. This file control various Terminal environment preferences including the path.
Create the .bash_profile file with a command line editor called nano
Android Debug Bridge (adb) is a versatile command line tool that lets you communicate with an emulator instance or connected Android-powered device. It is a client-server program that includes three components:
A client, which runs on your development machine. You can invoke a client from a shell by issuing an adb command. Other Android tools such as DDMS also create adb clients.
A server, which runs as a background process on your development machine. The server manages communication between the client and the adb daemon running on an emulator or device.
A daemon, which runs as a background process on each emulator or device instance.
Setup Devices for Debugging
Enable USB debugging on the handheld:
Open the Settings app and scroll to the bottom.
If it doesn’t have a Developer Options setting, tap About Phone (or About Tablet), scroll to the bottom, and tap the build number 7 times.
Go back and tap Developer Options.
Enable USB debugging.
Enable Bluetooth debugging on the wearable:
Tap the home screen twice to bring up the Wear menu.
Scroll to the bottom and tap Settings.
Scroll to the bottom. If there’s no Developer Options item, tap About, and then tap the build number 7 times.
Tap the Developer Options item.
Enable Debug over Bluetooth.
Set Up a Debugging Session
On the handheld, open the Android Wear companion app.
Tap the menu on the top right and select Settings.
Enable Debugging over Bluetooth. You should see a tiny status summary appear under the option:
Connect the handheld to your machine over USB.
In the Android Studio open the Terminal (Alt+F12 Windows) and run: