Bioinformatics Zen

Trimming 454 reads at the 5' end may improve fidelity

2013-05-13T09:15:00-04:00

A previous post described training machine learning classifiers to filter inaccurate reads in 16S-based metagenomic studies. This analysis was based on available mock community data - where an known set of 16S genes is sequenced and the generated reads compared to the original sequences. The value of using a mock community is that knowing the original sequences allows you to identify the types of errors you are observing in the output data. The method I previously used to find the accurate reads using the mock community data was as follows:

Remove barcodes and primers from reads and trim down to 200bp.
Select the unique representative reads and count how many times each unique read is observed in the data.
Build an alignment from N*2 of the most abundant unique reads. N is the number of sequences used in the mock community data.
Use single linkage clustering to group the aligned unique reads to within 4bp differences of each other. This merges the unique read that matches to with 4bp of another unique read into the more abundant read group.

The result of this method should be N unique reads in the output data and each unique read should then correspond to one of the mock community sequences. This approach assumes that after removing up to 4 single base errors and indels, the remaining most abundant unique read for each mock community sequence should be the correct one. This assumption can be described another way: any novel sequences generated from infidelity in the PCR or sequencing steps should not produce more copies than that of the original correct sequence.

I built this workflow with a combination of mothur and shell scripting. There is a gist on github illustrating this method of identifying correct reads based on abundance.

This approach bothered me because it does not actually compare the reads that I specify as correct against the original mock community. Therefore before pursing further machine learning approaches I aimed to first confirm the reads identified as accurate exactly match the mock community sequences.

Read fidelity in Quince et. al 2009 data

I used a simple approach to identify accurate reads in the 454 data: trim each mock community sequence to a 100bp substring and see how many reads contained this substring. I started with the divergent mock community data from Quince et. al 2009. This is the same data I used for machine learning approach to filtering inaccurate reads. I trimmed the community sequences to 100bp beginning at 5’ end and searched the generated read data for exact matching substrings using grep. The following code illustrates this approach with the resulting number of matches.

fastx_trimmer -l 100 -i SRX002564.community.tab -o trim100.fasta

grep --invert-match '>' trim100.fasta \
  | sort | uniq \
  | parallel 'grep {} SRX002564.fasta | wc -l' \
  | sort -r -n \
  | tr "\\n" " "

#=> 1609 1543 1024 14 5 5 4 4 3 3 2 2 2 2 1 1 0 0 0 0 0 0 0

This shows a large variance in the number of reads matching a mock community sequence substring. There are 3 with >1000 matching reads while the remainder of match <20 reads. I double-checked this result by examining a couple of the community sequence reads individually. This is illustrated below where the community sequence is shown in the top row and generated reads after removal of the primer are shown in the rows below.

>8                      CTA-ACGATGA-TACTCGAT
>SRR013437.14   tccacacc...A.......A........
>SRR013437.627  tccacacc...A.......A........
>SRR013437.935  tccacgcc...G.......A........
>SRR013437.2322 tcctcgcc...A.......A........
>SRR013437.2423 cccacgcc...A.......A........

>72                  GCCGTAA-CGATGAGAACTAGCC
>SRR013437.245  tccac.......A...............
>SRR013437.351  tccac.......A...............
>SRR013437.433  tccac.......A...............
>SRR013437.542  tccac.......A...............
>SRR013437.661  tccac.......A...............

This highlights that, for two of these mock community sequences, there appear to be insertions in the 5’ ends of the most abundant reads. These differences prevent exact substring matches to the mock community sequence. I considered if this was the case for the for further downstream sequence by repeating this process with a 100bp substring 50bp downstream from the 5’ end.

fastx_trimmer -f 50 -l 150 \
  -i SRX002564.community.tab \
  -o trim50_150.fasta

grep --invert-match '>' trim50_150.fasta \
  | sort | uniq \
  | parallel 'grep {} SRX002564.fasta | wc -l' \
  | sort -r -n \
  | tr "\\n" " "

#=> 2273 2229 1943 1873 1802 1795 1774 1701 1692 1677 1670
#   1628 1596 1573 1545 1522 1446 1442 1399 1356 935 635 548

This shows that using a substring 50bp further downstream finds a larger number of exact matches in the reads. The following figure compares the difference in the substring matches. The figure is on a logarithmic scale.

Read fidelity in the Human Microbiome Pilot Study

This examined only a single 454 run and one which was generated in 2009. I therefore considered further additional data determine if I observed this result again. The human microbiome project (HMP) has a pilot study which compares a single mock community with the output from several different sequencing centres. I repeated the above analysis with 9¹ from 19 of these sequencing experiments. I used a sample of 9 experiments to reduce overall analysis time.

The major difference with analysing these data is that there is no specific set of mock community sequences. The HMP instead used three pairs of primers to create amplicons from 22 genomes². I therefore created the 16S mock community³ by simulating PCR in silico using the primers and corresponding genomes. I then tested the HMP generated reads against this mock community using the same approach as before. The following figure compares the distribution of matching reads for the different substrings of the mock community.

This figure is harder to interpret because the two distributions overlap. There is less of a clear difference as to whether 5’ trimming results in a greater number of matches to the community substring. The following figure instead compares the difference in total number of matching reads for 5’ trimming versus no trimming. A larger value equates to a greater the number of substring-matching reads for the 5’ trimmed sequence versus the untrimmed sequence.

This figure shows that for two experiments 5’ trimming resulted in less matches to the community substring. In one of these cases this resulted in >3000 fewer matching reads. In seven of nine experiments however 5’ trimming of the mock community sequence increased the number of matching reads. In two cases 5’ trimming produced an improvement of >5000 exact substring matches.

Summary

The use of 3’ trimming in marker-based metagenomics is common. I am not familiar with any articles showing that 5’ trimming may improve read-fidelity however. I would be interested if anyone can highlight similar approaches. I think it may also be work considering if this 5’ trimming could be related to chimerism.

Trimming the 5’ end should not however be used in every case without prior consideration. Instead I believe a quality-control mock community should be added to each sequencing run to assess whether this is necessary. This way both 5’ and 3’ trimming could be tuned to each specific sequencing run. A similar point is argued in Schloss et. al 2011:

We have shown that even when sequencing centers follow the same procedures there is variation between and more importantly, within centers. The inclusion of a mock community sample on each sequencing run can be used to calculate the rate of chimerism, sequencing error rate, and drift in the representation of a community structure.

— Patrick D. Schloss mail, Dirk Gevers, Sarah L. Westcott. Reducing the Effects of PCR Amplification and Sequencing Artifacts on 16S rRNA-Based Studies. PLoS One.

If machine learning approaches are to be used to filter incorrect reads then the training data must be as accurate as possible. This means that every effort should be made to correctly label the accurate reads in the training data. Therefore I believe a constructing a machine learning filter may require the optimisation of two factors: how much of each read needs to be trimmed and how accurately the remaining reads can be accurately filtered for inaccuracy. This would balance read length for phylogenetic analysis against how may errors in the generated reads can be tolerated.

Footnotes

I used the HMP experiments: SRX020136 SRX020134 SRX020131 SRX020130 SRX020128 SRX019987 SRX019986 SRX019985 SRX019984. Each of these experiments contained 9 individual runs each making for a total of 81 454 GS FLX runs.↩
The accessions for the genomes used in the HMP pilot study are: AE017194 DS264586 NC000913 NC000915 NC001263 NC002516 NC003028 NC003112 NC003210 NC004116 NC004350 NC004461 NC004668 NC006085 NC007493 NC007494 NC007793 NC008530 NC009085 NC009515 NC009614 NC009617.↩
The HMP 16S mock community was created by simulating PCR amplification on the genome sequences using primer search and allowing up to a 20% mismatch against the primer sequence. Amplicons greater than 2000bp were discarded. The primer sequences were trimmed from the simulated amplicons except those with more than 2bp differences which were instead discarded.↩

Filtering inaccurate NGS reads using machine learning

2013-04-17T13:00:00-04:00

One of the earliest things I learned about next generation sequencing is to expect errors in the generated data. These errors include incorrect base substitution or incorrect estimation of regions of identical bases (homopolymers). When doing de novo genome assembly or genome resequencing these may not pose a problem as a majority consensus at each position can overrule these errors.

There are cases where inaccurate reads error do however cause a problem such as tag or marker sequencing. This is the study of a single gene from many different organisms with the goal of estimating polymorphisms or phylogeny. An example may be sequencing the same gene (e.g. 16S rRNA) from numerous microbes in the same environment. Another example is sequencing variations in viral genes to identify the the source of an epidemic. In both of these cases the single gene sequenced multiple times is the ‘marker’ of interest.

The advantage of this marker approach is that it generates a very large number of reads to allow surveying a population deeply. The problem is that sequencing errors can give false positives for diversity and variation. An extra base or a substitution generates a novel sequence and therefore a new genotypic signature. Furthermore when amplifying large quantities DNA even PCR errors can become relevant. This can be ‘chimeras’, where sequences mis-prime to each other generating a read composed of two origins. An additional rarer problem is PCR infidelity where base changes are introduced during the amplification process.

As the use of marker-based approaches increases, many articles are highlighting the need to identify and remove these poor quality reads. Not doing so can produce results biased by a large number of false positives leading to artefactually inflated diversity. If you are interested in the literature on this topic my citeulike page has some articles bookmarked.

I’m going to highlight one particular article: Reducing the Effects of PCR Amplification and Sequencing Artefacts on 16S rRNA-Based Studies by Patrick D. Schloss, Dirk Gevers and Sarah L. Westcott. Part of this article focuses on identifying inaccurate reads based on features of the reads. These features include the quality of the read, length of the longest homopolymer and so forth. I highly recommend this paper and it was one of the favourite articles I read last year. This paper caught my attention because the authors considered a wide range of features to identify inaccurate reads. This lead me to think that these features could be applied as a machine learning classification problem: given a set of labels (1 for an inaccurate ‘bad’ read, 0 for an accurate ‘good’ read) and the set of features (homopolymer length, read quality, etc) can I predict whether the read is bad and should be discarded?

The Data

For this analysis I’ll be using the mock community from the PyroNoise paper. This is an artificial community of 23 sequences that was 454 sequenced. I’m using this data because it is relatively simple to map the generated reads back to the original sequence. This thereby makes it straight forward to identify if a generated read is accurate. The short read archive identifier for this data is SRR013437.

I preprocessed this data by throwing away reads any shorter than 225bp. This value is 25bp for the primer and barcode and approximately 200bp of sequence that can be used for phylogenetic analysis after the barcode and primer are removed. The 200bp figure is approximate because there may be indels that are the natural differences between the sequences rather than sequencing error. The choice of 200bp is arbitrary and different cut-offs may yield different results. I followed this step by removing any reads containing ambiguous bases (‘Ns’) in the first 225bp. This preprocessing left 54370 reads to examine.

I generated two groups of data from the processed reads. The first was whether each read is inaccurate or not. This was resolved by grouping the reads into clusters based on identity. The top N clusters, where N is the number of sequences in the original mock community, are those reads which are correct, every other read was considered inaccurate.

The second data were the descriptive features from which to predict read accuracy. These data were divided into two groups the first was the longest homopolymer of each nucleotide type and the second was various quality metrics for each sequence. I also included original read length too. The distribution of these features for accurate and inaccurate reads looks as follows.

This data does not include all the features in Schloss et. al, for instance barcode and primer errors are not present. I selected only a subset of features as a starting point for a machine learning algorithm. Further features can be added in future. Given this feature set and accompanying accuracy labels, the next step was to create classifiers.

Classifiers

Heuristic Classifier

In the Schloss et. al article the authors compared several different heuristics for filtering and removing reads to improve quality. Two of these examined if the average quality score of a 50bp sliding window dropped below 35 and if there were homopolymers of any type greater than 8bp. In R this rule-based classifier might look as follows:

with(data,{
  prediction <- rep(0,length(bad.read))
  prediction[homop_ATGC > 8]     <- 1
  prediction[qual_min_50bp < 35] <- 1

  print.score("heuristic",prediction,bad.read)
})

The result of the print.score function are the following metrics:

Classifier	Pr(Correct Positive)	Pr(Correct Negative)	Matthews Correlation	Remaining Inaccuracy
Heuristic	0.660	0.663	0.321	0.337

The second and third columns of this table show the probability of when a read is identified as inaccurate (positive) or accurate (negative) given whether the read is actually inaccurate or accurate. These are the positive predictive and negative predictive values. The table shows that approximately 2/3 of reads are correctly identified in both cases. The Matthews Correlation Coefficient (Wikipedia) shows the overall performance of the classifier with a value of 1.0 being the correct classification in every case, 0.0 is equivalent to random classification, and -1.0 is the wrong classification in every case. The remaining inaccuracy shows how many of the reads are inaccurate after filtering with the given classifier.

Regularised Logistic Classifier

The first classifier I trained was a generalised logistic regression classifier. This uses a link function to map a linear regression to a value between 0 and 1. This regression can therefore be trained to classify whether reads are inaccurate or not. As a further step I used the glmnet package to fit an elastic net generalised logistic regression. This combines both L1 and L2 normalisation to penalise model coefficients with the aim of preventing model overfitting.

require('glmnet')

x <- as.matrix(data[,!(names(data) %in% c('read','bad.read'))])
y <- data$bad.read

model   <- glmnet(x,y,family=c("binomial"))
lambda  <- cv.glmnet(x,y,family=c("binomial"))$lambda.min
predict <- predict.logit(predict(model, newx=x, s=lambda))

print.score("logistic",predict,y)

Classifier	Pr(Correct Positive)	Pr(Correct Negative)	Matthews Correlation	Remaining Inaccuracy
Logistic	0.754	0.656	0.374	0.354
Heuristic	0.660	0.663	0.321	0.337

The logistic classifier performs better in correctly identifying inaccurate reads, almost 10pp (percentage points) better. At the same time there is a slight decrease in the number of reads incorrectly labelled as accurate: 0.7pp. This results in a greater remaining error rate in the filtered data: 1.7pp.

One useful consequence of a regression classifier is that the coefficients are relatively straight forward to interpret. The following figure shows the regression coefficients of this classifier for decreasing values of the regularisation coefficient lambda. The graphs are separated into two groups: the homopolymer coefficients and the quality coefficients. The coefficient for read length is not shown.

Not too much should be given to the interpretation of this figure as it is the result of training on only a single data set. This is apparent in the relatively low value of lambda. The figure does show that the minimum from a 50bp sliding window is the best predictor based on quality score. This is consistent with the results seen in Schloss et. al, the 10th percentile for minimum quality score over the length of the read also appears play a role in classification. Regarding homopolymer length the most important overall features associated with error appear to be homopolymers of G and C bases.

Random Forest Classifier

Random forest classifiers are one best performing algorithms in the field of machine learning. A random forest contains many individual decision trees each trained with a subset of the data and features. The predicted output is the modal average of all the forest classifiers.

require('randomForest')

rf <- randomForest(y=factor(data$bad.read),
                   x=data[,!(names(data) %in% c('bad.read','read'))],
                   ntree=500)
predict <- as.numeric(predict(rf)) - 1

print.score("random_forest",predict,data$bad.read)

Classifier	Pr(Correct Positive)	Pr(Correct Negative)	Matthews Correlation	Remaining Inaccuracy
Random forest	0.833	0.677	0.472	0.323
Logistic	0.754	0.656	0.374	0.354
Heuristic	0.660	0.663	0.321	0.337

The random forest performs well in correctly identifying inaccurate reads with a probability of 0.833 of a read identified as inaccurate actually containing errors. The probability of correctly identifying accurate reads remains relatively unchanged. The improvement in the Matthews correlation coefficient is therefore mainly due to the improvement in accuracy of which bad reads are identified - fewer correct reads are thrown away.

Ensemble Classifier

Combinations of machine learning algorithms often perform better than the sum of the parts. The ‘ensemble’ approaches may show improved performance when each of the classifiers models the problem domain with a different structure. For instance a regression classifier models the problem parametrically and linearly while a random forest is non-parametric and can find complex interactions. Combining two different algorithms of this type can, in some cases, combine the best of both worlds. I therefore created an ensemble classifier based on the random forest and logistic regression classifiers above. The results of this are as follows:

require('randomForest')
require('glmnet')

set.seed(1)

x <- as.matrix(data[,!(names(data) %in% c('read','bad.read'))])
y <- data$bad.read

rf <- randomForest(y=factor(y),
                   x=x,
                   ntree=500)
rf.pred <- predict(rf,type='prob')[,2]


glm.model <- glmnet(x,y,family=c("binomial"))
lambda <- cv.glmnet(x,y,family=c("binomial"))$lambda.min
glm.pred <- invlogit(predict(glm.model, newx=x, s=lambda))

weighted.predictions <- function(w,prob.a,prob.b){
  ifelse(((1-w)*prob.a) + (w*prob.b) > 0.5, 1, 0)
}

weight <- seq(0,1,0.01)
scores <- sapply(weight,function(w){
  score(weighted.predictions(w,rf.pred,glm.pred),y)
})

opt.weight <- weight[which(scores == max(scores))]
prediction <- weighted.predictions(opt.weight,rf.pred,glm.pred)

print.score("ensemble",prediction,data$bad.read)

Classifier	Pr(Correct Positive)	Pr(Correct Negative)	Matthews Correlation	Remaining Inaccuracy
Random forest	0.833	0.677	0.472	0.323
Ensemble	0.834	0.676	0.472	0.324
Logistic	0.754	0.656	0.374	0.354
Heuristic	0.660	0.663	0.321	0.337

The results of this are approximately the same as that of the random forest classifier. I can plot the performance of different weights between the random forest and the logistic regression for comparison. This figure shows clearly that the logistic classifier adds very little and that weighting mostly towards the random forest provides the optimum performance. I think this is likely the result of the random forest overfitting the data and cross validation across data sets may give more weight to the broader view provided by the logistic regression.

Summary

These current classifiers have not been tested for predictive power only the degree to which can explain the difference in between good and bad reads in a single data set. The predictive power should be tested by cross validation against multiple data from different experiments and sequencing centres. I would expect the Matthews correlation coefficients for the ML classifiers would be less than the values shown above because these classifiers have most likely overfit to this single data set.

As I wrote earlier, only a subset of features have been examined. For instance errors in the barcode and primer sequence have not been included. The Schloss et. al paper showed that these are also useful for identifying inaccurate reads. Therefore I think additional work should include features such as these. One machine learning approach throws as many features as possible at the problem and then uses normalisation to identify those with the most predictive power.

Given all of these caveats, there does appear to be a hard ceiling on the probability of identifying correct reads. Regardless of which classifier is used the probability of correctly identifying accurate reads is around 0.66. I hypothesise that this might be a problem of identifying chimeras - those sequences that form during the PCR step prior to sequencing. As chimeras are formed prior to sequencing, it could be considered extremely hard to identify them based on features associated with sequencing. Tools such as Uchime and Perseus should be combined in a pipeline to identify chimeras.

The main results of this small analysis appears to be to be the possibility of an increase in accuracy when identifying inaccurate reads for discarding. This, very initial, work suggests that using machine learning may be useful for increasing precision and therefore translate into fewer accurate reads being thrown away.

What's the point of publishing?

2013-02-27T08:00:00-05:00

What is the point of publishing? I think the answer most would give to this question would be ‘because I have to.’ You have to publish because a CV or resume full of publications allows to keep your job, apply for a new job, become a professor, and get tenure. I feel this myself and this need has become conflated with the desire to publish my research because I want to share it with the world. Pragmatically though I must regularly publish if one day I hope to see myself as a tenured professor.

Another answer a more career-secure researcher would give for publishing is ‘to share research among scientists.’ This is the reason journals were created so that large paper books could be distributed to universities. I am old enough to remember going to the library to physically photocopy the journal articles I wanted. A more specific question is then, given we have the Internet and many journals have become online only, ‘What is the point of publishing now?’

If a group of scientists were to come together to create a solution for sharing research would the current situation be close? That we spend weeks formatting research into Microsoft Word, or LaTeX if you’re lucky, for third-party publishers that will, after months or even years, eventually decide to disseminate to everyone. If our research is declined we then have to repeat this process for a different third-party publisher. Once this research is finally accepted many publishers will then charge scientists to finally get access to it.

This pay-for-papers situation means that many poorer institutions cannot access current research because they cannot afford the monthly subscription for the articles. You might think that perhaps these poorer institutions are mostly in the third-world. However if you have ever had to ask a colleague for a PDF then you are working at one of these poorer institutions. I think the list of non-poor institutions that have access to every journal subscription a researcher could need is very small or perhaps even 0.

You could argue then that open access publishers are fixing this situation. Open access journals charge researchers for publishing an article but then make the article free to access for everyone. There are still, however, limitations to open-access publication. For instance can you perform large scale analysis on the huge amounts of scientific data these open-access journals contain? Can you access structured citation data for these open-access journals?

A good question might be “who needs access to this large quantity of data?” Which scientist needs the citation information for all published articles? The answer is almost no one. The reason is the same for why most people don’t need to download the entire web to their computer. You only need to download the web pages you’re interested in. One group that does however need to download the entire web is Google. Their algorithm searches every web page to see which pages are linking to each other. This algorithm then identifies the top search results because they have many incoming links from other pages. Unfortunately there is no equivalent of Google for scientific publications. So while I can search the web an optimised search algorithm I am stuck in pre-Google days for searching the world’s research. All because the research is siloed across many individual journals.

A solution to the slow publication time of journals is to use pre-print servers. This means uploading your research to a different third-party that will make your research available to the community until it is more formally published in a journal. This situation means we have acknowledged that the journals so slow at publishing that we must an additional third-party to take up the slack. If we are becoming more happy using pre-print servers to share research doesn’t this mean that publishers are a becoming a vestige from a pre-Internet period?

You could argue that publishers provide an important a role in screening research through peer-review and journal exclusivity. However both of these functions are performed by academics rather than journals. So if academics are performing the necessary peer-review why do still need the journals? Is the lack of will to organise ourselves a good enough reason to put up with all the inefficiency, effort and costs that publishers bring?

Do we expect that the current status quo for sharing scientific research will still be the same 20, 50 or 100 years from now? If the answer to this is no, then why do we settle for it now?

What's the point of writing good scientific software?

2013-02-08T12:15:00-05:00

Software written by academics has a reputation of being poorer quality than that of software written by professional software developers. This poorer quality can be quantified by a lack of documentation, a non-intuitive interface, or bug-ridden with a tendency to crash.

I assume, since you’re reading a bioinformatics blog, that you’ve experienced trying to use code that you can’t download, won’t compile, won’t run on your system, isn’t documented, won’t work on your data, or just crashes without explanation. Speaking from personal experience this can be frustrating in the extreme. Consequently there are efforts to increase the quality of academic software including journals focused on publishing software with minimum standards and workshops to help academics write better software.

What then does good quality software look like? I think this includes both unit and integration tests to ensure the software works as expected. Revision control to ensure that bugs can be removed by reverting to the last working version. Continuous integration to make sure that software always passes tests when new changes are committed. Finally documentation of available options with examples helps users understand how to use the software. A question I have been recently asking myself however is what’s the point of spending the extra time to create better software?

Pubmed shows the number of articles published by two journals, ‘BMC Bioinformatics’ and ‘Bioinformatics,’ containing the word ‘software’ in the title or abstract is ~350 each year. I think this may an underestimate though since other journals also publish software articles and the terms ‘pipeline’, ‘package’ and ‘system’ may also be used instead of ‘software.’

Considering around 1700 bioinformatics software articles published in the last five years, this represents a significant corpus. This leads me to the question what is the point of writing good quality software if the chances are small that anyone will read about, or download it? For every highly cited tool, such as SAM Tools or PAML, there are likely many other tools which are never downloaded or used. Does it make sense to invest the extra time in the documentation and interface if there is a good chance that no one else will ever use it?

Let me illustrate with a concrete example. I’m a post-doc working in microbial genomics. I found that I had to write various scripts to help with the finishing of my genome and the subsequent upload to GenBank. I have previously believed that converting any code you’ve created into a open-source library benefits the community and prevents reinvention of the wheel. Therefore I converted my scripts first into a tool called scaffolder and then a subsequent tool called genomer. Both of these are tested with integration and unit tests, and I create documentation and screencasts.

I have however started to realise that perhaps something I thought would be very useful may be of little interest to anyone else. Furthermore the effort I have put into testing and documentation may not have been the best use of my time if no one but I will use it. As my time as a post doc is limited, the extra time effort spent on improving these tools could have instead have been spent elsewhere. Would it have been better if I have just completed the minimum to get them published then moved on to another project?

I have begun to think now that the most important thing when writing software is to write the usable minimum. If then the tool becomes popular and other people begin to use it, then I should I work on the documentation and interface. This will then ensure then I make the best use of my time without sinking effort onto something that could have little interest. Given the choice I like writing robust, well documented software but this takes extra time and in a competitive academic job market I feel like this is a luxury.

Poster: Predicting genotype from phenotype

2012-07-15T20:00:00-04:00

I presented the below poster at the 2012 American Society of Microbiology Meeting. This research demonstrates how we have been comparing and testing Pseudomonas strains for twitching motility to identify the genes responsible for phenotypic differences. Click on the image below to see a larger version.

As with my previous ASM poster, I think less text and a more visual overview is more likely to attract interest and start a discussion. ASM meetings usually have posters numbering in the thousands so I think a text-heavy poster can be a lottery for getting people to talk to you. A lighter poster, I hope, gives the impression that you’re not going to trap someone who expresses an interest with ten minutes of intense conversation.

Inspiration

I usually get started by on a new poster by searching the posters section on Deviant Art around a theme I am interested in. In this case I felt like going for “Grunge Minimalism.” There’s plenty of inspiration to be found on deviant art when searching for different themes and I was particularly inspired by the Alice in Wonderland poster by daveforyou. You can see similarities in the lines and colours between this poster and how I ended up designing mine.

Planning

I spend a large portion of my time planning a poster before opening Inkscape. I think time spent planning tends to pay off many-fold compared with trying to plan and create at the same time. My planning is rather straight forward: write down the key points I want to include and how I will lay them out on the poster. The images below show the papers I generated while planning the poster.

Images

I hand drew all the images using a black pen on squared paper. I draw them on squared paper to ensure that all image have the same proportions. Squared paper is also pretty handy for making accurate representations where it matters, for instance the genes in the upper right of poster are to-scale representations of the nucleotide length. I usually go through several iterations of each drawing until I get something I’m really happy with. Below are the final drawings I used for the poster.

After I’m happy with the images I scan them in using a standard office scanner to get a pdf. If you’re interested you can download the pdf of these scanned images. After scanning I import the pdf into Inkscape and convert each image to a path. Once in this state it is easy to simplify the object path and remove roughness or scanner artefacts. Below is the poster with the converted images.

Colours

The colours I used (blue and orange) are on opposing sides of the colour wheel and therefore complementary. Using a little colour theory can usually make a poster more visually appealing. I also experimented with how to apply these colours to the poster. I created seven different examples and asked my lab mates their opinions. The solid use of colours (upper left) was the most popular so this is the one I went for.

Font

Choosing a font is perhaps an underestimated but important point in designing a poster. A font should match the context around the text: use a serif thick font for loud and heavy impact or a lighter san-serif font for a more minimalist message. I used the Yanone Kaffeesatz after seeing it on Zack Holman’s slide design for developers blog post. I recommend reading his post too as it has many good points.

Summary

These are the main points on how I created my poster. The rest was just adding text, boxes and lines in Inkscape which is quite straight forward. Even if you do struggle with Inkscape usually a quick google search for the effect you’re after with find a tutorial. Overall, if I could offer a single suggestion it would be to spend a little time beforehand looking for inspiration and planning how you want your poster to look before you begin creating it.