Justin Kiggins

Zero Configuration Remote Jupyter Server

Mon, 18 Apr 2016 00:00:00 +0000

My personal laptop has a modest 4 core CPU, only 4 gigs of RAM and a 256GB hard drive. One of the servers in our lab, on the other hand, has 24 cores, 128GB of RAM, a 20TB file server, two Nvidia Tesla K40s, and one Titan Z GPU.

Which would you prefer to run your analyses on?

A while ago I set up Jupyter/IPython notebook servers for each user on our lab server. It hides them behind an nginx server, giving everyone a URL to access their notebooks that run on the server. It works, but there’s quite a bit of overhead involved (supervisord, nginx, etc).

The new postdoc in the lab showed me a way easier way to run a notebook remotely w/ no overhead. No nginx, no firewall configuration, and as secure as ssh. And now I’m going to show you.

jupyter notebook --no-browser --port=8888

So now you have a jupyter notebook running on your server at localhost:8888

Next, ssh into the server and forward a local port to the server’s port where jupyter is running:

ssh -NL 8888:localhost:8888 username@server

Now, open your browser and go to localhost:8888 and BAM you’ve got your remote jupyter server in your browser.

This approach is incredibly flexible… as long as you can open up an ssh connection to the server, you can run your notebook on the server using your browser as the interface:

@neuromusic As of now I can also confirm this method works for ssh-ing into Amazon EC2 instances, even with a key-pair.
— Grant (@usethespacebar) February 21, 2016

This opens up tons of possibilities…

If you use multiple Python environments on your server (say, one for each project), this methods lets you easily easily switch between them.
Even if you don’t have a headless server you need to connect to, maybe you are on a 5 hour flight and want to connect back to your workstation in the office. Easy peasy.

Try it. Let me know how it goes.

Moving from Matlab to Python: Where's my IDE?

Wed, 13 Apr 2016 00:00:00 +0000

It seems that one of the first challenges for Matlab users who want to get started with Python isn’t the language, but simply getting a development environment setup. Matlab eases onboarding through a single self-contained IDE. While there are IDEs for Python, I haven’t been happy with any of them. Instead, this is my development stack and the basic setup I recommend for new Python users.

Anaconda for Python & Package Management

To install Python and packages, I use the Ananconda Python distribution.

It works great across Windows, Linux, and Mac (though there are some quirks on Windows).

Anaconda is nice because it handles all of the complex C & fortran compilation needed for scientific computing really nicely.

It also comes with a command line utility called “conda” that (a) connects to their own package registry and (b) lets you run multiple environments so you can isolate projects from each other, each with their own dependencies.

Download Anaconda

Jupyter & IPython for Exploratory Analysis

Formerly called IPython, Jupyter is a browser-based interactive shell. You write and execute code in “cells”… the output shows up below each cell. You can reorder them or add a block of text. Then you can save the “notebook” file and send it to someone else to execute and explore.

I use this for exploring data, much as I would use the command line or “cell mode” in Matlab.

Once you start using it, Jupyter is extra awesome because you can do things like connect to your lab server installation from you browser while flying on an airplane with WAY less bandwidth than X11 forwarding or VNC. Jupyter is also language-agnostic, so you can run Julia, R, or even Matlab in Jupyter notebooks.

Get started with Jupyter

Sublime Text for File Editing

The time will come when you need to write a .py file.

You need to write a script to run on a server or overnight
You need a local file to hold some common helper functions for a project
You need to develop a package to be imported in multiple notebooks or scripts

For any of these, you need a text editor. Ostensibly, any text editor will do, but Sublime Text and Atom are very popular as they offer lots of features out of the box that make programming in Python nice (e.g. code completion, syntax highlighting, and smart indentation), and offer plugin systems to do even more (like unit testing and git integration).

Check out Sublime Text

If you really need an IDE, there are options. I’ve heard very good things about PyCharm though I find it slow on Ubuntu and Rodeo looks promising depite being quite bloated. For now, I’m quite happy with the Jupyter+Sublime combo.

Managing a neuroscience data pipeline with airflow

Sun, 03 Apr 2016 00:00:00 +0000

A few months ago, I found myself with a backlog of data that needed preprocessing before I could start really analyzing it. I decided I need some kind of a scheduler to help push my data through the preprocessing efficiently.

I ended up deploying Airflow. Since then, the whole lab has started using it. This is how we made it happen.

The pipeline

We have extracellular neural recordings and one of the major preprocessing steps is identifying neuronal spikes in the waveforms and clustering spikes that came from the same neuron. We are using the awesome package “phy” to do both of these steps, but there is a bit of preprocessing we need to do to prep our data for phy (de-noising the recorded signals and generating config files for phy).

This boils down to two major steps:

De-noising with our own python scripts.
Clustering with phy.

Step 1 is RAM-intensive & takes an hour or so. Step 2 takes many hours (possibly many days) and is CPU-intensive. Before airflow, I was using a simple bash script that runs these steps and a few others. But since I don’t want more than 1 or 2 batches in Step 1 at any given time, I’d fire off 2 batches, then log back in to the server a few hours later and run top to see what is running. If the batches have moved on from Step 1, then I can start a couple more batches. Check the log file to see if anything has failed and deal with those problems individually.

While “it works” it’s a pain to need to constantly be wondering what the status of all of this. If I’m not in the lab, I need to connect to the VPN then shh into the server. And that’s if I remember and I’m not asleep or whatever.

What I needed was a way to just add an analysis batch to a queue that only allows 1 or 2 batches to be running Step 1 at a time and no more than the number of processors running step 2.

We talked about SLURM or SGE but we’re just basically just running python scripts on one server. These tools are a bit of overkill for our needs.

This is what brought me to airflow, which was developed and open-sourced by Airbnb. The basic idea of Airbnb is that you define a set of Tasks and define dependencies in between Tasks, thus creating a Directed Acyclic Graph (DAG). Importantly, Tasks can get assigned to Pools. So if there are more Tasks that need run that slots available in the Pool, Tasks will get added to a queue and will execute once a slot opens in the Pool.

Boom. Looks like airflow will do exactly what we need out of the box.

However, I quickly discovered that this isn’t quite true.

Airflow was designed for an enterprise setup where you need to do things like “analyze the day’s log files and dump the results into a database”. What this means in Airflow terms is that you have a single DAG that runs every day (or on whatever schedule you want). This doesn’t really work for my data. I need to be able to run a DAG whenever I want with the appropriate parameters for that run.

I don’t want to re-hash topics covered in the wonderful Airflow tutorial, so I’m going to pickup where it left off.

For one batch, use one DAG

There are a few features of Airflow’s DAG’s that will let us do this.

First, instead of running DAGs are regular schedule, we can set the schedule_interval argument to None or @once.

dag = DAG(dag_id, 
          default_args=default_args,
          schedule_interval='@once',
)

With schedule_interval=None, you’ll need to manually run the dag at the command line with airflow trigger_dag dag_id when you are ready. If you are comfortable with the DAG getting run immediately, @once'

Generate DAGs dynamically

Second, since DAGs are defined as instances of DAG objects, we can generate them dynamically. For example, we can list the dag_ids in a text file and loop over it. Adding a new dag is as easy as appending a new line to the batches.txt file.

with open('batches.txt','r') as f:
    for line in f:
        dag_id = line.strip()
        dag = DAG(dag_id, 
            default_args=default_args,
            schedule_interval='@once',
        )
    
        …

        globals()[dag_id] = dag

For the example above, I iterated over a list of dag_ids, which is fairly boring. But you can see that it would not be hard to iterate over any set of parameters needed for a pipeline. For example, in my pipeline, I have two parameters: BLOCK identifies the batch that I want to process; it is used as the dag_id (because it is unique) and to set paths. OMIT is a list of my recording channels that I need to omit from the analysis & it’s a necessary parameter for Step 1.

Thus, I have file with BLOCK and OMIT separated by a tab.

Pen03_Rgt_AP2350_ML1400__Site04_Z2023__B957_cat_P03_S04_Epc17-18        Port_20,Port_21,Port_2,Port_23,Port_32,Port_29
Pen03_Rgt_AP2350_ML1400__Site04_Z2023__B957_cat_P03_S04_Epc29-33        Port_20,Port_21,Port_2,Port_23,Port_32,Port_29
Pen01_Lft_AP2500_ML1350__Site05_Z1536__B997_cat_P01_S05_Epc01-04        Port_16,Port_22,Port_30,Port_27,Port_28,Port_32,Port_29,Port_12,Port_31

And I can generate DAGs by crunching this file.

with open('/home/jkiggins/airflow/dags/blocks.tsv','r') as f:

    for line in f:
        args = line.strip().split()
        if len(args) < 2:
            continue
        BLOCK = args[0]
        OMIT = args[1]

        dag = DAG(BLOCK, 
                  default_args=default_args,
                  schedule_interval='@once',
        )

        make_kwd_task = BashOperator(
            task_id='make_kwd',
            pool='RAM',
            bash_command=make_kwd_command,
            params={'source_dir': '/home/jkiggins/data/mat/' % BLOCK,
                    'target_dir': '/home/jkiggins/data/phy/' % BLOCK,
                    'omit': OMIT},
            dag=dag)

        phy_task = BashOperator(
            task_id='phy_spikesort',
            pool='CPU',
            bash_command=sort_spikes_command,
            params={'target_dir': '/home/jkiggins/data/phy/' % BLOCK},
            dag=dag

        phy_task.set_upstream(make_kwd_task)

        …

Now that the whole lab is using it, it takes a bit of care not to step on each other’s toes. Airflow looks for dags in a shared folder (which we should probably put under version control). We’re basically just using one file per person/project. In addition to the RAM and CPU pools, we have a GPU pool for my labmates doing deep learning.

Generating Channel Graphs for KlustaKwik Automatically

Fri, 03 Jul 2015 00:00:00 +0000

In order to build the masks for KlustaKwik, SpikeDetekt2 needs to know the graph of adjacencies between all of the recording sites on a recording array. However, a bad channel for a recording session can drastically change the requirements for a probe geometry.

Luckily, there’s some math out there that can help us to build these adjacency matrices based solely on the geometry of the recording sites. I’ve already demonstrated how to use Delauney triangulation to do this for electrode arrays that are very large, where it would be a burden to define the geometry by hand. That was fun, but the technique has an application that I’ve already implemented into my own pipeline to extract population spiking activity.

We start with site maps in terms of Neuronexus recording sites

We are using we NeuroNexus probes. The recording sites are 1-indexed, whereas KlustaKwik uses 0-indexed channels (where each channel is a column in a 2D array). Further, due to our hardware configuration, NeuroNexus “Site 1” doesn’t necessarily correspond to KlustaKwik’s “Channel 0”. So we are going to define a site map that gives us the channel/index for each neuronexus site. The dictionary s is composed of site:channel pairs, where ‘site’ is the Neuronexus recording site and ‘channel’ is the index of that site’s recording in the Klustakwik *.raw.kwd file.

# site:channel
s = {11: 0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
     }

Sometimes you lose channels

Sometimes you don’t have all of your channels. Maybe a channel is bad on your headstage or you’re using one channel as a reference. Things happen. That shouldn’t prevent us from using the most complete adjacency matrix that we can.

We’re going pretend like we’ve have some dead (or unrecorded) sites by setting their channel to None

from numpy import random
from pprint import pprint

for dead_site in random.choice(s.values(),5):
    s[dead_site]=None

pprint(s)

{1: 24,
27,
30,
21,
18,
15,
12,
9,
6,
3,
None,
None,
7,
13,
19,
25,
28,
22,
None,
10,
None,
2,
None,
8,
11,
14,
17,
20,
23,
31,
29,
26}

Define our probe geometry in terms of the site map

If I were to manually define the adjacencies for each site on the NeuroNexus A1x32-Poly3-6mm-50 probe, this is what I would sketch:

 (3)      (30)
  | \    / |
 (2)-(17)-(31)
  | /    \ |
 (1)-(16)-(32)
  | \    / |
 (4)-(18)-(29)
  | /    \ |
 (5)-(15)-(28)
  | \    / |
 (6)-(19)-(27)
  | /    \ |
 (7)-(14)-(26)
  | \    / |
 (8)-(20)-(25)
  | /    \ |
 (9)-(13)-(24)
  | \    / |
(10)-(21)-(23)
  | /    \ |
(11)-(12)-(22)

Each number is the NeuroNexus site number and I’ve drawn my edges between them. This particular probe is a grid, so I have each square drawn and (for the sake of completeness) each square is split into two triangles. For KlustaKwik, I would need to write these out as a list of tuples.

Instead, we’re just going to define the probe geometry, giving the x,y coordinates of each site, where s[1] indicates site 1. If a different electrophysiology rig has a different hardware configuration, this will change, so it’s more robust to define this geometry in terms of the NeuroNexus sites.

Even though KlustaKwik doesn’t care about the geometry dict (except to plot the channels in Klustaviewa), we do. We are going to generate the graph on the fly from this geometry information, so I’ve defined it in microns, where the lower left recording site (Site 11) is (0,0).

channel_groups = {
    # Shank index.
    0: {   
        # List of channels to keep for spike detection.
        'channels': s.values(),

        # 2D positions of the channels
        # channel: (x,y)
        'geometry': {
            s[3]: (0,500), # column 0
            s[2]: (0,450),
            s[1]: (0,400),
            s[4]: (0,350),
            s[5]: (0,300),
            s[6]: (0,250),
            s[7]: (0,200),
            s[8]: (0,150),
            s[9]: (0,100),
            s[10]: (0,50),
            s[11]: (0,0), 
            s[17]: (50,450), # column 1
            s[16]: (50,400), 
            s[18]: (50,350), 
            s[15]: (50,300), 
            s[19]: (50,250), 
            s[14]: (50,200), 
            s[20]: (50,150), 
            s[13]: (50,100), 
            s[21]: (50,50),  
            s[12]: (50,0),   
            s[30]: (100,500), # column 2
            s[31]: (100,450),
            s[32]: (100,400),
            s[29]: (100,350),
            s[28]: (100,300),
            s[27]: (100,250),
            s[26]: (100,200),
            s[25]: (100,150),
            s[23]: (100,100),
            s[24]: (100,50), 
            s[22]: (100,0),  
        }
    }
}
pprint(channel_groups)

{0: {'channels': [24,
                  27,
                  30,
                  21,
                  18,
                  15,
                  12,
                  9,
                  6,
                  3,
                  None,
                  None,
                  7,
                  13,
                  19,
                  25,
                  28,
                  22,
                  None,
                  10,
                  None,
                  2,
                  None,
                  8,
                  11,
                  14,
                  17,
                  20,
                  23,
                  31,
                  29,
                  26],
     'geometry': {None: (100, 100),
                  2: (100, 0),
                  3: (0, 50),
                  6: (0, 100),
                  7: (50, 100),
                  8: (100, 50),
                  9: (0, 150),
                  10: (50, 150),
                  11: (100, 150),
                  12: (0, 200),
                  13: (50, 200),
                  14: (100, 200),
                  15: (0, 250),
                  17: (100, 250),
                  18: (0, 300),
                  19: (50, 300),
                  20: (100, 300),
                  21: (0, 350),
                  22: (50, 350),
                  23: (100, 350),
                  24: (0, 400),
                  25: (50, 400),
                  26: (100, 400),
                  27: (0, 450),
                  28: (50, 450),
                  29: (100, 450),
                  30: (0, 500),
                  31: (100, 500)}}}

Clean up the dead channels

We have a lot of Nones in there, indicating dead channels. Let’s strip those out.

new_group = {}
for gr, group in channel_groups.iteritems():
    new_group[gr] = {
        'channels': [],
        'geometry': {}
    }
    new_group[gr]['channels'] = [ch for ch in group['channels'] if ch is not None]
    new_group[gr]['geometry'] = {ch:xy for (ch,xy) in group['geometry'].iteritems() if ch is not None}
        
channel_groups = new_group
pprint(channel_groups)

{0: {'channels': [24,
                  27,
                  30,
                  21,
                  18,
                  15,
                  12,
                  9,
                  6,
                  3,
                  7,
                  13,
                  19,
                  25,
                  28,
                  22,
                  10,
                  2,
                  8,
                  11,
                  14,
                  17,
                  20,
                  23,
                  31,
                  29,
                  26],
     'geometry': {2: (100, 0),
                  3: (0, 50),
                  6: (0, 100),
                  7: (50, 100),
                  8: (100, 50),
                  9: (0, 150),
                  10: (50, 150),
                  11: (100, 150),
                  12: (0, 200),
                  13: (50, 200),
                  14: (100, 200),
                  15: (0, 250),
                  17: (100, 250),
                  18: (0, 300),
                  19: (50, 300),
                  20: (100, 300),
                  21: (0, 350),
                  22: (50, 350),
                  23: (100, 350),
                  24: (0, 400),
                  25: (50, 400),
                  26: (100, 400),
                  27: (0, 450),
                  28: (50, 450),
                  29: (100, 450),
                  30: (0, 500),
                  31: (100, 500)}}}

Build the adjacency graph from the probe geometry

Next, we’ll use SciPy’s built-in Delaunay Triangulation to construct a graph from the probe geometry

from scipy import spatial
from scipy.spatial.qhull import QhullError
def get_graph_from_geometry(geometry):
    
    # let's transform the geometry into lists of channel names and coordinates
    chans,coords = zip(*[(ch,xy) for ch,xy in geometry.iteritems()])
    
    # we'll perform the triangulation and extract the 
    try:
        tri = spatial.Delaunay(coords)
    except QhullError:
        # oh no! we probably have a linear geometry.
        chans,coords = list(chans),list(coords)
        x,y = zip(*coords)
        # let's add a dummy channel and try again
        coords.append((max(x)+1,max(y)+1))
        tri = spatial.Delaunay(coords)
    
    # then build the list of edges from the triangulation
    indices, indptr = tri.vertex_neighbor_vertices
    edges = []
    for k in range(indices.shape[0]-1):
        for j in indptr[indices[k]:indices[k+1]]:
            try:
                edges.append((chans[k],chans[j]))
            except IndexError:
                # let's ignore anything connected to the dummy channel
                pass
    return edges


def build_geometries(channel_groups):
    for gr, group in channel_groups.iteritems():
        group['graph'] = get_graph_from_geometry(group['geometry'])
    return channel_groups

channel_groups = build_geometries(channel_groups)
print(channel_groups[0]['graph'])

[(2, 8), (2, 3), (3, 2), (3, 8), (3, 7), (3, 6), (6, 7), (6, 3), (6, 10), (6, 9), (7, 8), (7, 11), (7, 3), (7, 6), (7, 10), (8, 2), (8, 3), (8, 7), (8, 11), (9, 6), (9, 10), (9, 12), (10, 7), (10, 11), (10, 6), (10, 9), (10, 14), (10, 13), (10, 12), (11, 7), (11, 8), (11, 10), (11, 14), (12, 13), (12, 15), (12, 10), (12, 9), (13, 14), (13, 17), (13, 12), (13, 15), (13, 19), (13, 10), (14, 13), (14, 17), (14, 10), (14, 11), (15, 12), (15, 13), (15, 19), (15, 18), (17, 13), (17, 14), (17, 20), (17, 19), (18, 19), (18, 15), (18, 22), (18, 21), (19, 18), (19, 15), (19, 20), (19, 17), (19, 13), (19, 22), (19, 23), (20, 19), (20, 17), (20, 23), (21, 18), (21, 22), (21, 25), (21, 24), (22, 18), (22, 19), (22, 21), (22, 25), (22, 23), (23, 25), (23, 26), (23, 22), (23, 19), (23, 20), (24, 25), (24, 21), (24, 27), (25, 29), (25, 26), (25, 28), (25, 21), (25, 22), (25, 24), (25, 27), (25, 23), (26, 29), (26, 25), (26, 23), (27, 28), (27, 30), (27, 25), (27, 24), (28, 31), (28, 30), (28, 29), (28, 27), (28, 25), (29, 28), (29, 31), (29, 25), (29, 26), (30, 28), (30, 31), (30, 27), (31, 28), (31, 30), (31, 29)]

That was way easier than doing it by hand

Let’s see what it looks like…

%pylab inline
def plot_channel_groups(channel_groups):

    n_shanks = len(channel_groups)

    f,ax = plt.subplots(1,n_shanks,squeeze=False)
    for sh in range(n_shanks):
        coords = [xy for ch,xy in channel_groups[sh]['geometry'].iteritems()]
        x,y = zip(*coords)
        ax[sh,0].scatter(x,y,color='0.2')

        for pr in channel_groups[sh]['graph']:
            points = [channel_groups[sh]['geometry'][p] for p in pr]
            ax[sh,0].plot(*zip(*points),color='k',alpha=0.2)

        ax[sh,0].set_xlim(min(x)-10,max(x)+10)
        ax[sh,0].set_ylim(min(y)-10,max(y)+10)
        ax[sh,0].set_xticks([])
        ax[sh,0].set_yticks([])
        ax[sh,0].set_title('group %i'%sh)
            
        axis('equal')
        
plot_channel_groups(channel_groups)

Populating the interactive namespace from numpy and matplotlib

Fantastic

If we had just dropped our missing sites, we’d have huge gaping holes in our graph. Instead, we now have a bunch of edges linking past the dead sites, keeping our graph in tact.

view the ipython notebook

Defining Large Array Geometries for Klustakwik

Thu, 02 Jul 2015 00:00:00 +0000

We’ve started using KlustaKwik for spike sorting in the lab and I’ve been working on getting a data pipeline going. It’s masked EM algorithm is very clever, taking into account the adjacency matrix of an electrode array to determine whether it should use one, two, or n recording sites when clustering.

However, very large arrays make it unrealistic to manually define the probe architectures that SpikeDetekt2 expects. For example, the dense silicon arrays designed by Ed Boyden’s group:

5 shanks with 200 sites each and just 11 microns pitch between sites

This example programmatically builds a channel_groups dictionary for a large array, using just a handful of parameters of the array.

first, we need to be able to convert a geometry into a graph

we’ll define a function which takes the geometry dict, extracts the coordinates, and uses the Delaunary transformation to generate a triangular tesselation. It then returns this graph in the form that SpikeDetekt2 expects

from scipy import spatial
from scipy.spatial.qhull import QhullError
def get_graph_from_geometry(geometry):
    
    # let's transform the geometry into lists of channel names and coordinates
    chans,coords = zip(*[(ch,xy) for ch,xy in geometry.iteritems()])
    
    # we'll perform the triangulation
    try:
        tri = spatial.Delaunay(coords)
    except QhullError:
        chans,coords = list(chans),list(coords)
        x,y = zip(*coords)
        coords.append((max(x)+1,max(y)+1))
        tri = spatial.Delaunay(coords)
    
    # then build the list of edges from the triangulation
    indices, indptr = tri.vertex_neighbor_vertices
    edges = []
    for k in range(indices.shape[0]-1):
        for j in indptr[indices[k]:indices[k+1]]:
            try:
                edges.append((chans[k],chans[j]))
            except IndexError:
                pass
    return edges

Now, we can build the probe definition from a few basic parameters

This is suitable to write directly to a *.prb file for SpikeDetekt2

w = 2 # the width of the grid of sites
l = 100 # the length of the grid of sites
n_shanks = 5 # the number of shanks
pitch = 11 # site spacing in microns

channel_groups = {}
for sh in range(n_shanks):
    # define the channels on this shank
    channels = [sh*w*l+ch for ch in range(w*l)]
    
    # get the physical coordinates by including the spacing
    row_col = [(ch/w,ch%w) for ch in [c%(w*l) for c in channels]]
    coords = [(pitch*c, pitch*(l-1)-pitch*r) for r,c in row_col]
    
    # then  assign these to the geometry dictionary
    geometry = {ch:xy for ch,xy in zip(channels,coords)}

    # finally, use our function from above to define the graph
    graph = get_graph_from_geometry(geometry)

    channel_groups[sh] = {
        'channels': channels,
        'graph': graph,
        'geometry': geometry,
    }

Did it work?

Let’s plot it.

import matplotlib.pyplot as plt

f,ax = plt.subplots(1,n_shanks)
for sh in range(n_shanks):
    coords = [xy for ch,xy in channel_groups[sh]['geometry'].iteritems()]
    
    for pr in channel_groups[sh]['graph']:
        points = [channel_groups[sh]['geometry'][p] for p in pr]
        ax[sh].plot(*zip(*points),color='k',alpha=0.2)
        
    ax[sh].set_xlim(-5,pitch*(w-1)+5)
    ax[sh].set_ylim(-5,pitch*(w-1)*n_shanks+5)
    ax[sh].set_xticks([])
    ax[sh].set_yticks([])
    ax[sh].set_title('shank %i'%sh)
    ax[sh].scatter(*zip(*coords),color='0.2')

There we go. 1000 recording sites, ready to be sorted by KlustaKwik.

view the ipython notebook

Nothing in NeuroData Makes Sense Except in Light of Behavioral Annotations

Sat, 29 Nov 2014 00:00:00 +0000

I had the opportunity to give a short talk at the Neurodata Without Borders Hackathon on behavioral annotation for neurophysiology data.

Don’t Panic! Elsevier’s #OpenAccess policy is not malicious

Mon, 18 Aug 2014 00:00:00 +0000

Yesterday, I noticed a comment on Twitter where Erin McKiernan expressed confusion over Elsevier’s Open Access policy:

Q: Have you seen an exclusive license requirement on open access publishing agreements? Surely not BOAI compliant. @MikeTaylor?

— Erin McKiernan (@emckiernan13) August 16, 2014

This was promptly jumped on by other Open Access advocates, who were insisting that it is “not OA”, “nasty”, and even “malice”:

@MikeTaylor @emckiernan13 By definition that is not OA.

— Charles Oppenheim (@CharlesOppenh) August 17, 2014

@krisshaffer @CharlesOppenh @MikeTaylor Yup. Nasty, isn’t it? And they aren’t the only ones doing it. Really should be actionable, I think.

— Erin McKiernan (@emckiernan13) August 17, 2014

.@emckiernan13 @CharlesOppenh WHAT THE ACTUAL F*&£ They’ve now crossed the line where this can’t be written off as ignorance. It’s malice.

— Mike Taylor (@MikeTaylor) August 17, 2014

I burned through a few dozen tweet yesterday trying to convince Erin, Mike, & Charles that the exclusive license isn’t a problem for OA at all. This is particularly important because (as of Aug 18) Erin has incorporated this criticism into an Open Letter to the Society for Neuroscience regarding the new Open Access journal, eNeuro, which uses the same licensing scheme (my own emphasis added):

Our first concern relates to the copyright policy of eNeuro. The journal’s policy states that authors will retain copyright but must grant the Society an exclusive license to publish. An exclusive license is in conflict with the tenets of open access, as defined by the Budapest Open Access Initiative (BOAI), and does not reflect the aims of the Creative Commons licenses to allow reuse.

The problem here is that the exclusive license is something that you (the author and copyright holder) grant to the publisher. It is a guarantee to them that you will not take your original content elsewhere. Alone, this would indeed be sketchy, but since both journals turn around and release the article under a CC license, anyone (including the author) can reuse and redistribute the article subject to the terms of the CC license*.

Elsevier’s author agreement actually illustrates this really well:

used without permission

You grant the publisher exclusive publishing rights then they release the paper under the OA-compliant CC license. There is no adverse impact on the Open Access goals. It is entirely consistent with the Budapest Open Access Initiative. The limitation that it does place is preventing a line directly from the Author to the User. This can actually be useful, as I’ll explain soon.

Above, I used a photo by the very kind-hearted Dustin Gaffke, who shared his photo of Panic! At The Disco on Flickr with a CC-BY license. Thus, I was able to download the photo and upload it here with the proper attribution (noting the copyright holder and providing a link back to the source). This is how the CC-BY license works. I can do all kinds of things with his photo… I can make money off of it, printing it on T-shirts and sell them in the alley outside of Panic! At The Disco concerts, as long as I print “photo by Dustin Gaffke”. I could modify the photo, add my own color effects, mash it up with other photos to make my own Creative Work. Just gotta note the original creator and how it was modified. This is how the CC-BY license works.

However, Dustin is still the copyright holder. He can still do whatever he wants with photo. Maybe Panic! At The Disco likes his photo so much they want to use it for their own promo materials but they don’t want to have to remember to add the proper attribution every time they put it on a mug or poster or concert flyer. He could grant them a license to use the photo without his name (something I can’t do).

Now, the CC-BY license works the same for scholarly works. Releasing under CC-BY doesn’t just let other people read your work without having to pay, but it allows them to redistribute and reuse it. This led to a bit of a kerfuffle last summer, when some scholars realized that their freely downloadable CC-BY papers were getting compiled into textbooks that were being sold for $100+. Now, this anger was largely due to a misunderstanding of what is permitted under CC-BY, but there were some instances where the CC-BY license may have been violated (e.g. poor attribution by omitting a link to the original article and changing the title without noting that the work had been changed). However, we’ll probably never know whether the more dubious practices of Apple Academic Press actually violated CC-BY because they probably will never go to court. Here’s why:

Lets assume for a moment that we see a similar scenario that would be an egregious violation of CC-BY… a textbook gets printed with entire chapters lifted directly from published papers without any attribution for the original author or manuscript whatsoever.

The only way to enforce licensing is litigation, so who sues?

That burden falls on the copyright holders, i.e. the authors of the manuscript. The publisher of the CC-BY paper can’t really do anything to enforce the CC-BY because the original authors (who still have copyright) could have very easily licensed the material to the textbook publisher, as it is wholly within their right to do so, just as it is within Dustin’s right to sell rights to the Panic! At The Disco photo.

Because of this issue, the publisher doesn’t have a case. I would also guess that the academics probably don’t have the time/money/wherewithal to hire lawyers.

However, if the authors have granted an exclusive license to the publisher as Elsevier and the Society for Neuroscience require, they are guaranteeing to the publisher that they will not license the work to anyone else. The publisher can then distribute the work with the CC-BY license. The exclusive license between the copyright holder and the publisher in no way restricts, modifies, or changes the CC-BY license.**

What the exclusive license does allow, though, is for the publisher to pursue legal recourse in the event of a CC-BY violation. They know that (a) they have an exclusive license from the copyright holder and (b) they distributed the work under a CC license. Remember how there is no direct line between the Author and the User in Elesevier’s handy flowchart? So if the work shows up somewhere without attribution, it is obviously a violation of the CC license. The only additional restriction here imposed by the exclusive license is on the author, who must now conform to the CC-BY license as well. They can no longer stick excerpts into a textbook chapter without attributing the original paper.

Is it confusing? A bit, but Elsevier’s Author Guidelines lay it out pretty clearly.

Is it necessary? Not strictly.

Is it helpful? Yes, in at least one scenario.

Is it still OA? Yes.

Is it “malice”? Absolutely not.

n.b. If you are an IP lawyer, feel free to correct me on any of this.

An open letter to Larry Swanson: Why it is important for neuroscientists to debate the Brain Initiative in public

Mon, 15 Apr 2013 00:00:00 +0000

Dear Larry Swanson,

I’m writing in response to your letter to SfN members regarding the Brain Initiative, primarily because I strongly disagree with one of your key points. In the letter, you write:

While we should all continue to explore and discuss questions about the scientific direction, it is important that our community be perceived as positive about the incredible opportunity represented in the President’s announcement. If we are perceived as unreasonably negative or critical about initial details, we risk smothering the initiative before it gets started.

and

SfN encourages healthy debate and rigorous dialogue about the effort’s scientific directions. Testing of assumptions, methodological debate, and constructive competition are central to scientific progress. I urge you to bring all this to the table through our scientific communications channels and venues, including the SfN annual meeting in San Diego this fall and The Journal of Neuroscience.

(my own emphasis added)

To summarize your request, you think that we should disagree only in “our scientific communications channels” while ensuring that, to the taxpayers who will be funding this initiative, “our community be perceived as positive” about it. Not only do I find it offensive and patronizing that you would ask us to be disingenuous to the very public which supports our efforts, but I think that your request is short-sighted and undermines the work of neuroscientists who seek to cultivate a public that is informed and literate in matters of the brain.

The debate has already begun in the public sphere, whether you like it or not. And the public is looking to neuroscientists to make sense of the vague official announcements that have happened thus far. Will we actually fix Alzheimer’s in five years? Will we record from every neuron in the human brain? Why do we want to do this? Without our informed input to the debate, “we risk smothering the initiative before it gets started” due to bad reporting. While you ask us to stick to “our” channels of scientific discourse, like the paywalled journals and exclusive conferences that the public cannot access, it was only 4 days after the New York Times story broke that this gem of fear-mongering claimed that the Brain Initiative would allow Barack Obama to read people’s minds. If we don’t talk about the Brain Initiative, bad reporters will. And if bad reporters talk about the Brain Initiative, we risk creating a public which is fearful of the very work that we do.

That is, while pieces like those by Partha Mitra, Scicurious and other neuroscientist bloggers may not have portrayed a community of neuroscientists that are 100% united behind this initiative, they serve a much greater purpose. As you noted, we are “capturing the world’s attention” and this affords us an “unparalleled” opportunity to educate the public about the actual work that neuroscientists do, the opportunities and the limitations. This type of discourse is critically needed in the public sphere to improve neuroscience literacy, fight bunk neuroscience reporting, and in the long run cultivate a public that is excited, engaged, and ready to fund neuroscience.

Further, most of the debate among neuroscientists on Twitter, Quora, and blogs concerns where the money for this initiative will be coming from and whether it will cut into existing (and already strained) research budgets. I think that we are entirely valid in being concerned that other good neuroscience will be “smothered” by the Brain Initiative, precisely due to the “growing challenges caused by shrinking or flat national government budgets for science research.” And again, putting this debate in the public sphere allows neuroscientists to inform the public on the opportunities and limitations of different experimental approaches, and the importance of investing in basic research for long term health outcomes.

Ultimately, I believe that we should not wait until SfN in November to debate this and that we should not isolate the debate from the public that supports us by locking it off on the pages of “our” journals that are inaccessible to said public. Rather, having this debate in the open will ensure a public that supports and trusts our work for decades to come.

Thank you,

Justin Kiggins

claimtoken-519e641d7f3d9

the “value” of protesting

Fri, 14 Dec 2012 00:00:00 +0000

A quick thought, inspired on twitter:

Money is protected as “free speech”, hence lobbying is legal. We can give money to other persons to speak for us.

Could we nail down the “value” of protesting? That is, what is the amount of money I would need to donate to my cause such that I could stay home and sit on my couch instead of protesting?

If we have a given bill (say to tighten gun controls), lets say that the pro-gun folks dedicated $100 Million against and had 1000 protestors outside of congress, while the anti-gun folks rummaged up only $1 Million, but got 100,000 protestors.

For simplicity, lets say that the vote is a tie, meaning that both sides were equally effective.

We could then just solve for x, where x is the value of a single protestor…

100,000,000 + (x * 1000) = 1,000,000 + (x * 100,000)
999,000,000 = x * 99,000
x = $10,091

… which sounds very high to me (made up numbers, of course).

Analyzed across, say, all of the bills before congress during a given session, though, one could perhaps get an estimate of the value of protesting.

Hmm… surely a political economist has done this?

“Occupy Oakland October 11″ CC-BY quinn norton

moving beyond the low-hanging #altmetrics fruit

Tue, 30 Oct 2012 00:00:00 +0000

Here are the #altmetrics that I want to see for individual research papers:

How many journal clubs are discussing this?
How often was this mentioned at campus pubs?
How many entrepreneurs saved this into their Mendeley library?
How many lives were saved because of this?
How many patents were inspired by this?
What is the increase in GDP attributable to this research?

Ultimately, any efforts to move beyond basic citation metrics to assess the impact of scientific research should move us closer to actually measuring the actual impact of said research. Scientists often cite the benefit of basic research for the advancement of economic prosperity and human health and this is the kind of impact we should be trying to assign metrics to.

“Low hanging fruit” CC-BY Caza_No_7