Monday, June 30, 2014

Data Analysis for Genomics

http://genomicsclass.github.io/book/

HarvardX: PH525x Data Analysis for Genomics

IEEE SPS / UBC ICICS Summer School on Signal Processing and Machine Learning for Big Data



PROGRAM
In natural language processing, latent Dirichlet allocation (LDA) is a generative model that allows sets of observations to be explained by unobserved groups that explain why some parts of the data are similar. For example, if observations are words collected into documents, it posits that each document is a mixture of a small number of topics and that each word's creation is attributable to one of the document's topics. LDA is an example of a topic model and was first presented as a graphical model for topic discovery by David Blei, Andrew Ng, and Michael Jordan in 2003.[1]

https://sites.google.com/site/s3pbigdata2014/program

IEEE SPS / UBC ICICS Summer School on Signal Processing and Machine Learning for Big Data

   


 
Tuesday
July 29
Wednesday
July 30
Thursday
July 31
Friday
August 1
 9:00-9:30Opening ceremony
  
 9:30-10:30
Konstantinos N. Plataniotis
University of Toronto
Angshul Majumdar
IIIT-Delhi
Ali Bashashti
BC Cancer Agency
Ozgur Yilmaz
University of British Columbia
 10:30-11:00Coffee breakCoffee breakCoffee breakCoffee break
 11:00-12:00
Vikram Krishnamurthy
University of British Columbia
Angshul Majumdar
IIIT-Delhi
Tom Levi
Plenty Of Fish
Michael Friedlander
University of British Columbia
 12:00-13:00LunchLunchSocial event with lunch
Rayan Saab
University of California, San Diego
 13:00-14:00
Georgios Giannakis
University of Minnesota
Martin McKeown
University of British Columbia
 
 14:00-14:30Coffee breakCoffee break  
 14:30-15:30
Georgios Giannakis
University of Minnesota
Li Deng
Microsoft Research
  


Monday, June 2, 2014

Java generics

http://docs.oracle.com/javase/tutorial/java/generics/types.html

The most commonly used type parameter names are:
  • E - Element (used extensively by the Java Collections Framework)
  • K - Key
  • N - Number
  • T - Type
  • V - Value
  • S,U,V etc. - 2nd, 3rd, 4th types
public interface Pair<K, V> {
    public K getKey();
    public V getValue();
}

public class OrderedPair<K, V> implements Pair<K, V> {

    private K key;
    private V value;

    public OrderedPair(K key, V value) {
 this.key = key;
 this.value = value;
    }

    public K getKey() { return key; }
    public V getValue() { return value; }
} 
 
public class Box<T> {

    private T t;          

    public void set(T t) {
        this.t = t;
    }

    public T get() {
        return t;
    }

    public <U extends Number> void inspect(U u){
        System.out.println("T: " + t.getClass().getName());
        System.out.println("U: " + u.getClass().getName());
    }

    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<Integer>();
        integerBox.set(new Integer(10));
        integerBox.inspect("some text"); // error: this is still String!
    }
}
 
A type variable with multiple bounds is a subtype of all the types listed in the bound. If one of the bounds is a class, it must be specified first. For example:
Class A { /* ... */ }
interface B { /* ... */ }
interface C { /* ... */ }

class D <T extends A & B & C> { /* ... */ }