The 2016 Backdoored Cryptocurrency Contest Winner

2016-08-31T22:43:00+00:00

Thanks to a quite a bit of luck I won this years version of the Underhanded Crypto Contest focused on crypto currencies. The submission consists of a writeup and – of course – backdoored code.

Can Miners Exploit a Block Size Increase?

2015-06-23T10:49:00+00:00

We don’t know yet. But modelling is in my opinion a useful tool to investigate potential effects. Therefore, I used Gavin Andresen’s mining simulator to create some more or less plausible scenarios. You can find the resulting plots on github.

FCW Kernel

2014-12-12T01:50:00+00:00

A Feature Coinciding Walk Kernel classifies nodes in a graph.

This project is a python port of Coinciding Walk Kernels (CWK) [1] and introduces an extension of the model called Feature-CWK (FCWK). If you want to jump right into some code see the benchmark.

CW-Kernels deal with the problem of node classification (aka link-based classification) in which a set of features and labels for items are given just as in regular classification. In addition, a node classification algorithm accepts a graph of of items and item-item links. It has been shown that the additional information that is inherent in the network structure improves performance for certain algorithms and datasets.

Read More

Visualizing Receptive Fields

2013-02-14T00:37:00+00:00

The following article will visualize some mathematical models for brain cell activity. In some regions of the brain, neurons are excited or inhibited by neurons of a preceding input layer. They are called receptive field of that neuron. Since the visual area uses receptive fields as feature detectors (such as edge and edge-orientation detection) for natural images, the application of different receptive field functions on images can be nicely examined. The ipython notebook file to play with the parameters can be found on GitHub.

In [2]:

import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import scipy.signal as signal
import numpy as n

We examine the effect on the following images. In the visual pathway the images can be seen as input from the retina to higher visual areas.

In [3]:

barImg=mpimg.imread('bar.png')
#extract grey values
barImg = barImg[:,:,3]

In [5]:

imgplot = plt.imshow(barImg, cmap=cm.Greys_r)

In [6]:

img=mpimg.imread('stinkbug.png')
#extract grey values
bugImg = img[:,:,0]

In [7]:

imgplot = plt.imshow(bugImg, cmap=cm.Greys_r)

Receptive field functions

The two dimensional gaussian function is used in image processing as blurring filter. $$\phi(x,y) = \frac{1}{2\pi\sigma^2}\exp{(-\frac{1}{2\pi\sigma^2}(x^2+ y^2))}$$

In [8]:

def gaussian2D(x, y, sigma):
    return (1.0/(1*math.pi*(sigma**2)))*math.exp(-(1.0/(2*(sigma**2)))*(x**2 + y**2))

Since scipy's convolve function does not accept functions, we sample sample the function.

In [9]:

"""make matrix from function"""
def receptiveFieldMatrix(func):
    h = 30
    g = zeros((h,h))
    for xi in range(0,h):
        for yi in range(0,h):
            x = xi-h/2
            y = yi-h/2
            g[xi, yi] = func(x,y);
    return g

In [10]:

def plotFilter(fun):
    g = receptiveFieldMatrix(fun) 
    plt.imshow(g, cmap=cm.Greys_r)

The gaussian function is circular symmetric, leading to excitation of a centered pixel from nearby pixels in convolution.

In the context of fourier transformation it is a low pass filter, which cancels out higher frequencies in the frequence domain of the image and is therefore blurring the image.

In [11]:

plotFilter(lambda x,y:gaussian2D(x,y,4))

Convolution is the process of applying the filter to the input, which is the image $I(x,y)$ denoting the grey value of the pixel at the specified position. $$\int \int I(x',y')\phi(x-x',y-y')dx'dy'$$

When applying the gaussian filter every neuron in the output layer is excited by nearby image neurons. The result of the convolution can then also be visualized in an image. Song Ho Ahn has a nice example for convolution of 2D Arrays.

In [13]:

Img_barGaussian = signal.convolve(barImg,receptiveFieldMatrix(lambda x,y: gaussian2D(x,y,5)), mode='same')

In [14]:

imgplot = plt.imshow(Img_barGaussian, cmap=cm.Greys_r)

In [15]:

Img_bugGaussian = signal.convolve(bugImg,receptiveFieldMatrix(lambda x,y: gaussian2D(x,y,3)), mode='same')

In [16]:

imgplot = plt.imshow(Img_bugGaussian, cmap=cm.Greys_r)

Difference of Gaussians

The mexican hat function is a difference of gaussians, which leads to an on-center, off-surround receptive field, found in retinal ganglion cells or LGN neurons. It can be seen as a basic edge detector.

In [12]:

def mexicanHat(x,y,sigma1,sigma2): 
    return gaussian2D(x,y,sigma1) - gaussian2D(x,y,sigma2)

In [17]:

plotFilter(lambda x,y: mexicanHat(x,y,3,4))

In [18]:

Img_barHat = signal.convolve(barImg,receptiveFieldMatrix(lambda x,y:mexicanHat(x,y,3,4)), mode='same')

In [19]:

imgplot = plt.imshow(Img_barHat, cmap=cm.Greys_r)

In [23]:

Img_bugHat = signal.convolve(bugImg,receptiveFieldMatrix(lambda x,y: mexicanHat(x,y,2,3)), mode='same')

In [25]:

imgplot = plt.imshow(Img_bugHat, cmap=cm.Greys_r)

Gabor functions

Gabor functions are used to detect edges with a specific orientation in images. Neurons which can be modeled using gabor functions are found throughout the visual cortex.

Odd gabor: $$g_s(x,y):=sin(\omega_x x + \omega_y y)\exp{(-\frac{x^2+y^2}{2\sigma^2})}$$ Even gabor: $$g_c(x,y):=cos(\omega_x x + \omega_y y)\exp{(-\frac{x^2+y^2}{2\sigma^2})}$$

Orientation is given by the ratio $\omega_y/\omega_x$.

$g_s$ is activated by step edges, while $g_c$ is activated by line edges.

In [26]:

def oddGabor2D(x,y,sigma,orientation):
    return math.sin(x + orientation*y) * math.exp(-(x**2 + y**2)/(2*sigma))

In [27]:

def evenGabor2D(x,y, sigma, orientation):
    return math.cos(x + orientation*y) * math.exp(-(x**2 + y**2)/(2*sigma))

In [28]:

plotFilter(lambda x,y: oddGabor2D(x,y,7,1))

In [29]:

Img_barOddGabor = signal.convolve(barImg,receptiveFieldMatrix(lambda x,y: oddGabor2D(x,y,5,1)), mode='same')

In [30]:

imgplot = plt.imshow(Img_barOddGabor, cmap=cm.Greys_r)

In [35]:

Img_bugOddGabor = signal.convolve(bugImg,receptiveFieldMatrix(lambda x,y: oddGabor2D(x,y,5,1)), mode='same')

In the following plot one can see clearly the edge orientations that excite the neuron.

In [36]:

imgplot = plt.imshow(Img_bugOddGabor, cmap=cm.Greys_r)

Using the on-center, off-surround receptive field image as input to the gabor we obtain different results.

In [46]:

Img_bugOddGaborEdge = signal.convolve(Img_bugHat,receptiveFieldMatrix(lambda x,y: oddGabor2D(x,y,5,1)), mode='same')

In [47]:

imgplot = plt.imshow(Img_bugOddGaborEdge, cmap=cm.Greys_r)

In [37]:

plotFilter(lambda x,y: evenGabor2D(x,y,7,1))

In [39]:

Img_barEvenGabor = signal.convolve(barImg,receptiveFieldMatrix(lambda x,y: evenGabor2D(x,y,5,1)), mode='same')

In [40]:

imgplot = plt.imshow(Img_barEvenGabor, cmap=cm.Greys_r)

In [41]:

Img_bugEvenGabor = signal.convolve(bugImg,receptiveFieldMatrix(lambda x,y: evenGabor2D(x,y,5,1)), mode='same')

In [42]:

imgplot = plt.imshow(Img_bugEvenGabor, cmap=cm.Greys_r)

Quadrature Pairs

A complex cell might react equally well to step edges and lines of either polarity. This is modeled by summing the squared responses of both odd and even gabor filter.

In [43]:

def edgeEnergy(x,y,sigma, orientation):
    g1= oddGabor2D(x,y,sigma,orientation)
    g2= evenGabor2D(x,y,sigma,orientation)
    return(g1**2+g2**2)

In [44]:

plotFilter(lambda x,y:edgeEnergy(x,y,50,0))

In [48]:

Img_barEdgeEnergy = signal.convolve(barImg,receptiveFieldMatrix(lambda x,y: edgeEnergy(x,y,100,1)), mode='same')
imgplot = plt.imshow(Img_barEdgeEnergy, cmap=cm.Greys_r)

In [54]:

Img_bugEdgeEnergy = signal.convolve(bugImg,receptiveFieldMatrix(lambda x,y: edgeEnergy(x,y,10,1)), mode='same')
imgplot = plt.imshow(Img_bugEdgeEnergy, cmap=cm.Greys_r)

References

Introduction to Computational Neuroscience, Hanspeter Mallot, University of Tübingen

Signaling Games and Language

2012-11-29T00:15:00+00:00

Two papers I wrote with Roland Mühlenbernd last winter. We mainly explored what happens when the players are able to invent new messages in signaling games. The important finding in the first paper is that the players ability to make up new messages overcomes signaling bottlenecks and leads to successfull communication even if the number of strategies is high. When coupled with a reasonable mechanism for message extinction, the agents will play perfect strategies in the end. The second paper explores the evolution of the vowel space with this technique. The resulting partitions of the vowel space resemble these of actual languages.

Kinect Data in Blender

2012-11-28T20:17:00+00:00

Importing raw data points from Microsofts Kinect is fun, despite my lacking blender skills. But the huge filesizes prevent further use.

Category: python | nickler's