If you prefer publishing blog posts on medium.com or other external sources, starting version v0.5.0, al-folio lets you to display your external posts in the blog feed of your website! 🎉🎉

Configuring external sources of super simple. After upgrading to v0.5.0, just add the following section to your _config.yml:

external_sources:
  - name: medium.com  # name of the source (arbitrary string)
    rss_url: https://medium.com/@<your-medium-username>/feed

The example above adds your medium.com blog post feed as an external source. But you can add arbitrary RSS feeds as sources.

Any questions or suggestions? 👉 Start a discussion on GitHub!

My girlfriend is looking for a new position. As she goes through the process it became important to understand more about who we were reaching out to. Enter Glassdoor. This isn’t a plug, that’s just what they do. In order to read reviews, they ask that you submit a review of your own first. I wanted to test that.

Site Navigation

Navigating Glassdoor is easy enough. There’s a search bar, entering the company name and selecting the result will take you to their page. This is where the adventure begins.

As you can see navigation stops once this is presented. If the browser takes awhile to load sometimes you can scroll and peak at the other information, but once the lock loads that stops. Each link is also a separate page, which forces the browser to reload the lock.

If we open up the console we can look at what is creating the lock.

Console Navigation

Hovering over the items we see “hardsellContainer”, which sounds exactly like something we’re looking for, containing the display lock elements. One of the elements is the container for the social media login options. Another element creates the shadowing effect, establishing the webpage as a background for the social media links. Because of the hierarchal nature of elements, deleting the parent element deletes any children elements.

Deleting the lock elements allows us to see the company’s information but still prevents us from scrolling. There’s a few mechanisms that would prevent a page from scrolling, but a common one is the overflow property. If we inspect the main body of the page we see that the overflow property is set to hidden. Unchecking it should allow the user to scroll at will. If that’s not the case, check the other elements for the overflow property to see if it was redefined.

Discussion

I’m quite surprised at how easy it was to get around Glassdoor’s security. Granted, it’s not anything you can’t already get for free (so long as you have a social media account), but that it’s 4 clicks start-to-finish to circumvent a well presented security feature at a well-known company. It’s also interesting to think about the of the barrier of entry to do this; a web browser you’re already using, and its console. Anyone who has watched a 5 minute intro video into web design is already intimately familiar with the tools needed to do this. It sort of begs the question what other sites are like this, and how can they be circumvented. While there’s entire fields dedicated to that, this is from the perspective of someone not in those fields.

I used Chrome for this, Firefox or Safari should work with some tweaks.

FIJI is an open source image analysis tool for the scientific community. This post demos how to use some of the tools FIJI has, including data collection techniques.

Initial Data

The image for this demo is of starburst amacrine cells (SACs), interneurons in the retina. The image is a single channel .tif, 512x512 pixels, with each pixel representing 0.62 microns. With this information we definitively measure how big each cell is.

Brightness & Contrast

The first thing I do is adjust the brightness and contrast. By looking at the histogram we can see that the image is very dark, more dark than it needs to be. Lowering the maximum value fills out the range of present colors. The difference is clear in Figure 2.

It’s important in this step to not over-saturate the image by raising or lowering the minimum/maximum values. This step is to present the information within the image as a whole. Tweaking and refining will come later.

For this demo I want to look at the cells, not the nebulous background or nodelets. Given that, the image doesn’t need to be as bright. However, it’s important to note that brightening the image revealed more cells and provided better definition. Where this middle ground is depends on the observer and whatever their interests are.

Threshold

Thresholding is an important first step in many image analysis techniques. It converts the image to a black and white image. Here I adjust the histogram in the same fashion as before and focus it around the peak. That filters out the background while keeping true to the cell size and shape.

Sometimes after adjusting the image, the subject matter may blend together. In this case applying the threshold created some peanut shaped objects. Watershed segmentation addresses the issue and cuts the “peanut” in half. Figure 4 highlights the effect.

Analyzing the Image

This is where the magic happens. Once the cells are properly individualized we can count and measure each cell. FIJI automatically does this. Since I’m interested in the size and position of the cells I’ve excluded any cells that are cropped by the edge. From here the data is exported to a .csv file.

MATLAB

The exported data contains a cell ID, area, and x/y position. First, I want to determine if the size of the cells fits any distribution. The Jarque-Bera Test tests the normality of a dataset and MATLAB has a built in function for this. Applying the JB test to the data gives a result of 1, meaning that the test rejects the hypothesis that the data (cell size) is normally distributed.

We can also look at the nearest neighbor of each cell (see Figure 6).

So the size of the cells aren’t interesting, but what about the spatial distribution of the cells? Using the data provided by the image, we can calculate the coefficient of variation:

μ = 21.0440

σ = 5.3968

CoV = σ/μ = 0.26

(units are in microns)

Defining λ as the average distance of the nearest neighbor (21.0440), the Poisson coefficient of variation is:

CoV = λ^(-1/2) = 0.22

A Poisson distribution assumes that cells are “blind” to each other’s positions as they develop and can’t occupy the same space. The fact that these coefficients are close infers that these SACs are also blind as they develop.

Neuron Anatomy

Neurons generally have four functional regions; input, integration, conduction, and output. Inputs are generated current flowing in and out of the cell. Inputs are aggregated, and if triggered, generate an action potential and releasing neurotransmitters. In this exercise I examine the intracellular activity of a cell and determine how many presynaptic cells are providing an input, as well as the activity level of each input.

Initial Data

To visualize the data I plotted it as a heat map. The left image shows all of the data, the right image displays fewer samples, highlighting the different inputs the cell is receiving.

The data is a series of voltage measurements over time; if we look at a covariance matrix (Figure 3) it would be able to show us how the voltage measured at each time point vary together.

Principal Component Analysis (PCA)

From there we can run PCA on the data, seen in Figure 4. Three PCs stand out in that they explain more fractional variance than the other PCs, but ultimately we would need hundreds to explain all of the data. By plotting those three principal components we can clearly see three signal responses (Figure 5, left). Looking at the histogram (Figure 5, right) confirms that the 4th PC has a gaussian centered at 0, a strong indicator of noise.

K-means Classification and Event Identification

Now that we have a waveform with which to use, we can use a classifier. In this exercise I use the K-means tool in MATLAB to comb through the data and ‘classify’ the inputs based on the PCA, counting each time a synapse event occurs. In this example each event occurred 587, 108, and 127 times respectively. There’s a number of guides and videos on how K-means works.

Color Specific Photoreceptors - Cones

Inside the retina are cone cells, photosensitive cells that differentiate color. Humans have 3 different types of cones; (S)mall, (M)edium, and (L)arge, corresponding to the length of the wavelength that excites it. The excitement amplitudes of each type of cone is perceived to us as color, and the color perceived is the sum of each cone response.

Radial Basis Functions

A Radial Basis Function (RBFs) is a function whose value depends the distance between a query point and a fixed point. For this exercise I used the Gaussian Function:

• x is the query point
• c is some fixed point, 0 if distance is measured from origin
• h(x) is the RBF

By using multiple RBFs you can approximate a function. By multiplying the RBF by some weight, summing a network of RBFs can approximate a function:

• h(x) is the RBF
• w is the weight for the RBF
• j in the index for m samples of x

The weight vector can be found using linear regression, ultimately leading to this equation:

• H is the design matrix of h(x), or a nxm matrix of n samples and m RBFs
• y is f(x) vectorized

In this exercise we have the following dataset:

• x is drawn from a uniform random distribution, from -10 < n < 10; n=1,000
• y = 2x + e; e is a normally distributed noise vector, $μ = 1, σ = 0$
• Use 48 RBFs, between -12 and 12 @ every 0.5 along the x axis

Fig. 1 - Dataset visualized

Fig. 2 - 48 RBFs plotted

Fig. 3 - Function approximation

Fig. 4 - Error analysis

Modeling photoreceptor response provides insight to how information is gathered and processed at the cellular level. It’s the network of these cone cells that provide the stimulus we interpret as color.

Emulated Neurons

Neural networks are built on units called neurons, and for this exercise a special neuron called a perceptron is used. Perceptrons are special in that they can represent fundamental logic functions: AND, OR, NAND, NOR. Though a perceptron can’t represent XAND or XOR, layered perceptrons can, thus all logic functions can potentially be built using a layered network structure.

images showing perceptrons' logic structure

Perceptrons work by multiplying a vector of inputs by a weight vector and passing the sum of that input-weight vectors through an activation function. For this exercise I used the sigmoid function, but there are many others. Weights are [nxm] matrices, where n is the dimension of the input and m is the dimension of the output.

image showing perceptron model

Here is a sketch algorithm to implement a perceptron node:

\(\Sigma (x_iw_i ) = x_1w_1 + x_2 w_2 + ... + x_nw_n\)

\(\sigma = \frac{1}{1+e^{\Sigma (x_iw_i )}}\)

• x is the sample input
• w is the the associated weight for the input sample

For the perceptron to work properly, the weights need to be adjusted according to the desired output. To calculate and adjust the error we first subtract the predicted output from the actual output.

\(\epsilon=y-\sigma\)

• ϵ is the error
• y is the acutal output
• σ is defined above

Using gradient descent, we find the adjustment needed for the weights by computing the derivative of the sigmoid function and multiplying that by the error to give us the final adjustment for the weights:

\(\sigma' = \sigma (1- \sigma)\)

• σ’ is the sigmoid derivative when given σ as above

\(adjustment = \epsilon*\sigma'\)

Networked together, perceptrons can be immensely powerful and are the foundations by which many neural nets are built. These new weights wouldn’t have changed much, but over many iterations they converge to their proper values of minimizing error. This method of adjusting the weights is called backpropagation.

To test the algorithm a small, simple sample set was used to provide easy-to-interpret results. The table below shows the following dataset such that the output is 1 if first or second columns contained a 1, disregrading the third column:

perceptron.py demonstrates the algorithm and predicted output. Given the input array and initial weights adjusted 200​ times, the predicted results are as follows:

Given an infinite number of iterations the algorithm would converge to either 0 or 1, but in 200 iterations our results are close enough to see a clear distinction.

Applied to a larger dataset, classifier.py, we can create a linear classifier.

Left: Initial 2D dataset, Right: Perceptron classifier results

Left: Initial validation dataset, Right: Perceptron validation classifier results

The graph below shows the network error over 500 iterations. As expected the initial error is very high due to the weights being initially random. The error quicky drops after ~30 iterations, but never quite reaches zero. In this case error is ~4%, reflected in the misclassifed samples in both images on the right.

Network error percentage drops after each epoch, indicating a model is being learned