Showing posts with label notes. Show all posts
Showing posts with label notes. Show all posts

Wednesday, October 1, 2014

Relation between precision and recall in binary classification

Let $tp, fp, fn,$ and $tn$ be the number of true positives, false positives, false negatives and true negatives obtained on some set by a binary classifier. Let $P$ and $R$ be the precision and recall given by $P=\frac{tp}{tp+fp}, R = \frac{tp}{tp+fn}$. Let $N=tp+fp+fn+tn$ be the total size of the set. The precision and recall for the negative class are $P'=\frac{tn}{tn+fn}, R'=\frac{tn}{tn+fp}$.

We want to show that $P'$ increases with $R$, and $R'$ increases with $P$ (and hence analyzing the performance of any one class is sufficient).

We use $$P'=\frac{N-(tp+fp)-fn}{N-(tp+fp)} = 1 - \frac{fn}{N-(tp+fp)}$$, and
$$R = \frac{tp}{tp+fn} \Rightarrow tp+fn = \frac{tp}{r} \Rightarrow fn = tp(\frac{1}{R}-1)$$, to get $$P' = 1 - (\frac{1}{R}-1) \frac{tp}{N-(tp+fp)} = 1 - (\frac{1}{R}-1) \frac{1}{\frac{N}{tp}-(1+\frac{fp}{tp})}$$.

$R$ increases when $tp$ increases (if $fn$ decreases, then $tp$ has to increase). Also, an increase in $tp$ has no effect on $fp$. Thus, by increasing $R$ (or $tp$), the second term in the RHS to decrease, thus increasing $P'$. QED.

A similar relation holds between $P$ and $R'$ by symmetry between the two classes.

So what?
  1. When comparing the results from two binary classifiers, we might be interested in how the classifiers performs on both classes, rather than just one. In such cases, it is sufficient to compute both precision and recall for one of the classes and compare the same for the two classifiers. If one classifier has better precision on the positive class, it also means that it has better recall on the negative class. 
  2. If we want to find the best hyper-parameters for a classifier using grid search, and we want to find the parameter for which the the classifier does  well on both classes, then we could define "best" in terms of a score that incorporates both precision and recall (e.g. the F1 score). This ensures, e.g., that precision is not optimized at the cost of recall (i.e. at the cost of precision of the negative class).

Friday, April 6, 2012

Notes from ECIR 2012

quantum computing
- lattice (set theory)
- spectral theorem


designing search
- design depends on the context, which comprises
    - user (expert, novice, disabled, etc.)
    - task (adhoc, targeted, transactional, etc.)
    - environment (at home, on the move, on a desktop, on an phone, etc.)
- prioritize design goals
    - who am i designing for?
    - who am i _not_ designing for?
- faceted browsing: facets should be
    - exhaustive
    - consistent (e.g. (N.India, S.India) is ok, but (N.India, Bangalore) or (N.India, > Rs.10000) is not ok)
    - Orthogonal / Non-overlapping
    - Of roughly the same size


Paolo Boldi
    - centrality measures; empirical study of how it correlates to node importance
    - has open software on his website for this (HyperANF at ...unimi.it)
    - geodesic, centrality
    - centrality measures (first 3 are geometric indexes)
        - based on degree
        - based on no. of paths
        - based on how close it is to others
        - spectral indexes   
    - Lin centrality, harmonic centrality
    - Kendall's tau
    - computing centrality using diffusion
    - Pregel implementation
    - whitelist
    - naturalistic study


- neyman pearson lemma
- probability ranking principle (stephen robertson)


Explaining query modifications: An alternative interpretation of term addition and removal
- how and why do users modify queries
- what do they assume about how the search engine works





Predicting the Future Impact of News Events
- use various attributes to predict the various attributes
- use std ML techniques (SVR, feature selection)

Detection of News Feeds Items Appropriate for Children
- classify an article as 'appropriate' or 'not'
- use BBC data (labeled 'for children', and 'for adults')
- std readability measures (use info gain for feature selection)
    - ARI, flesch-kincaid


Yoelle Marak
- usage data
    - query log
    - click data
    (- mouse track
     -eye track)
- searchwiki
- demographics of web search. wsdm 2011
- anatomy of the long tail. wsdm 2010


- B-cubed precision and recall: to evaluate soft-clustering

- kdd 2006. "... center ... graph ... extraction ..."

- trustRank (pagerank with bias towards inlinks from reliable pages)

- unique sets ratio

- Geometric MAP, instead if MAP

- statistical significance testing
    - parametric tests (eg. T-test)
    - non-parametric tests
   
- TREC. Banks. Variance due to topics.
- Chi-square test: to check if disribution is Normal
- Shapiro-Wilks test

- BoxCox transformation
- ACE algo (alternating conditional expectation)


- axiomatic approach. fang et al. sigir 2004

- 'bursty' distribution

- Lemur, Terrier systems

Leif Azzopardi et al. top-K retrieval.
    Chen and Karger. SIGIR 2006. Top-K retrieval.
    Prob Ranking Principle. Robertson.
    MMR. Carbonell and Goldstein. 1998
    modern portfolio theory. wang and zhu. ecir 2009
    quantum prob ranking principle. zuccon and azzopardi. ecir 2010
    comparison of ranking principles. zuccon, azzopardi, van rijsbergen. ictir 2011
    gollapudi and sharma. 2009. facilities placement and top-k
- language model with dirichlet smoothing
- alpha-nDCG@10
- diversification
    - kuland and kee, santos et al


latent variable model
- max margin latent variable model, for inducing relevance functions
- log linear model p(x) = e^h(x) / sum_x' e^h(x')
- subgradient method for parameter estimation
- data sets (image)    - SUN, MIR Flickr
- Global SVM, Transductive SVM


1000 search engines
- problem of search
    - many data sources: www, wiki, news, patents, tweet
    - many result types: docs, temp, curr, people
    - many relevances: topical, recency
- probabilistic relational algebra (PRA)

context aware recommendation
- tensor factorization
- ndcg, auc, loss functions
- stochastic GD, alternating least squares, bundle methods

TagME
- tagme.dl.unipi.it
- milne and witten 2008
- earthmover distance (on graphs?)
- "combinatorial"
- wsdm 2012 paper on result clustering
- Lingo, Lingo 3G
- Carpineto, Osinski, et al. ACM Comp Surv 2009
- Carpineto et al. SIGIR 2010.
    - Optimal seach results clustering
    - kSSL (method for evaluating search result clustering), AMBIENT (data set)
- relative mean difference
- TreeNet tool
- Boosted decision trees

* Listen to all talks, to guage the audience. Then tune own presentation accordingly. (Dont say things that everyone knows. Dont forget to say things that most dont know.)

Thursday, January 5, 2012

I am attending a School on Network Science at ECE, IISc, organized as part of the IMI, and funded by ICTS. I jotted down some points for revision/future look-up.

Networks, Rumours, and Epidemics [Dr Ayalvadi Ganesh]
References
  • Grimmett and Frieze
  • Damon Mosk-Aoyoma and Devavrat Shah. Distributed Computation of Separable Functions. IEEE Trans. Info. Theory. 2008
  • Consensus. de Groot et al.
  • Voter model. Hassin and Peleg, James Cruise and Ganesh Ayalvadi
  • Wright-Fisher model, Morale model
  • Wisdom of Crowds. Golub and Jackson
  • Acemoglu, Dahleh, Lobel, Ozdaglar
  • Kermack and McKendrick. Epidemic model using ODEs
  • Ganesh Ayalvadi, Moussalie, Tousley. Effect effect of network topology on epidemic spread. IEEE InfoComm. 2005
  • Draief, Ganesh, Moussalie. thresholds for Virus Spread on Nertworks. Ann. Appl. Prob. 2008
Topics
  • Coupon Collector Problem
  • Stochastic Domination, Strassen's Theorem
  • Markov Chains---irreducible, aperiodoc, ergodic, balance equations, invariant distribution, etc.
  • Markov Process (continuous time)
  • Poisson Process---thinning
  • Martingales, stopping time, Optional Stopping Theorem
  • Binary Entropy function, Conditional entropy
  • Random walks---coalescing RW
  • Coupling from the past in MCMC
  • Erdos-Renyi graphs, scale-free graphs, expander/ing graphs, unimodular graphs
  • Linear recurrences, harmonic functions
  • Lattices---infinite lattice
  • Perron-Frobenius Theorem---sprectral radius, Perron eigenvalue
  • Eigenvalue of e^A, where A is a matrix
  • Generalized isoperimetric constant
Ising Models [Andrea Montanari]
Topics
  • Hammersley-Clifford Theorem
  • Inclusion-Exclusion Principle
  • Union bound
  • Measures, Concentration
  • Gibbs sampling, MCMC, Metropolis
  • Constrastive Divergence (Hinton)
  • Glauber Markov Chain
  • tanh, atanh---properties
  • "One-dimensional recursion"
  • Inequalities---Markov, Chebyshev, ...
  • Sterling number---as related to enumerating number of graphs with p vertices and Cp edges 
  • Belief propagation, Generalized BP
  • Contraction (on graphs)

Friday, December 30, 2011

I recently started reading the book Introduction to Information Retrieval by Manning, Raghavan and Schuetze. It's a wonderful book. I plan to jot down some notes here from time to time.

Chap. 5 is about  index compression. There are 3 motivations for this-
  • reduce disk space required to store the index
  • reduce transfer time between memory and disk
  • make it possible to store parts of the index in main memory (with on-the-fly decompression when it is used)
 Statistical properties of the index are interesting, as they enable estimation of quantities such as number of terms, number of postings, average number of postings, etc. This in turn helps in the choice of appropriate compression algorithms. Two laws are discussed, both power laws.
  • Heap's Law: to estimate the number of (unique) terms (M)
    • M = k T^b, where T is the number of tokens, and k and b are constants.
    • b>0. We get a straight line with positive slope in the log-log scale.
    • Roughly speaking, this implies that the vocabulary keeps growing as the size of the corpus grows---it does not level off.
  • Zipf's Law: to estimate the size of the postings lists (f, for frequency/no. of occurrences in the collection)
    • f = k r^b, where r is the rank of the term (ordered by frequency), and k and b are constants (b<0).
    • Roughly speaking, this implies that the r^th most frequent word occurs 1/r times the most frequent word.
Dictionary compression allows us to keep the dictionary in memory, leading to faster query processing (by avoiding one disk seek).
  • The simplest case is no compression. Store records of the form <term, pointer to postings list>, where the term field is restricted to a certain length. Look for terms using binary search.
  • Dictionary as a string: Store the terms in the form <t1,t2,t3,...> as one long string. Then store records of the form <termPtr, postingsPtr>. termPtr is an offset from the beginning of the string where a particular term begins. The number of characters to be read is calculated by subtracting from the next termPtr. Look for terms using binary search.
    • Blocks of strings: Fix a block size k. Store strings as <l1,t1,l2,t2,l3,t3,l4,t4,...> where li is the length of ti stored in a single byte, and (l1,t1,...lk,tk) constitutes a block. Then store records of the form <blkPtr, postingsPtr1, ..., postingsPtrk>. blkPtr is an offset from the beginning of the string where a particular block begins. Look for terms using binary search to identify the block, and using sequential search within the block.
  • Front coding: Suppose the block coding string is <6,drawee, 6,drawer, 7,drawing, 5,drawl>, then instead use <6,draw*ee, 2,#er, 3,#ing, 1,#l>. That is, identify a prefix for a subsequence of the dictionary string, and use a special character (#) for that prefix.
  • Minimal perfect hashing: Choose a minimal perfect hash function h() for the vocabulary. Store records of the form <n, postingsPtr> where n = h(t) is the integer that the term hashes to. Looking for a term is a straightforward hash calculation. This method is not suited when the set of terms keeps changing.
  • If the dictionary cannot be stored in memory even after compression, store them on disk and add the first term of each disk page to a B tree. Looking for a term will require at most one disk seek.
 Postings compression saves disk space, allows faster reads from disk, and allows caching of postings of popular terms in memory.
  • With no compression, the postings list looks like <docId1, docId2, ...>. If there are N documents in the collection, storing each docId requires logN bits. However, storing the gap between consecutive docIds requires fewer bits. For example, suppose there are 1024 documents, then storing <3, 7, 36, 49> requires log1024*4 = 40 bits. But if we knew that consecutive docIds are never more than 32 apart, then storing the offsets as <3, +4, +29, +13> requires 10 + 3*log32 = 25 bits.
  • Variable Byte encoding: In the example above, the offsets are stored in 5-bits. In principle, an offset can be as large as N, and require logN bits. But most offsets are much smaller. Hence, a variable length encoding of offsets is used as follows. Given the postings list <824, 829, 215406>, the `gap list' is <-, +5, +214577>. In binary, this looks like <110 0111000, 101, 1101 0001100 0110001>. In the encoding, it is stored as <00000110 10111000, 10000101, 00001101 00001100 10110001>. The 0 and 1 indicate whether this is the last byte of the encoding or not. The underlined sections how where 7-bit pieces from the binary form of the number are stored in the encoding.
    • The unit of encoding can be changed from 8 bytes to 4 or 16 or 32. Larger units lead to lesser bit manipulation but results in less effective compression.
  • Gamma coding: Suppose the offset is 13 (i.e. 1101). Then store 1110101. This is got by removing the leading bit and taking the rest (101)---called the offset, and prepending it with the length of the offset (3) stored in unary (1110). While reading a gamma code, read upto the first 0---this is the length of the offset that follows. Read the offset and prepend a 1 to it. 
    • The optimality of the encoding depends on the data. It can be shown that gamma codes take at most twice as many bits as the optimal encoding for any data.
    • Gamma codes are prefix free (no code is a prefix of another, so that no delimiters are required) and parameter free (no parameters to fit/estimate before encoding can begin; also no re-estimation required when the postings lists change).
Gamma codes gives better compression than variable byte encoding but are more expensive to decode.

Thursday, December 29, 2011

I recently started reading the book Introduction to Information Retrieval by Manning, Raghavan and Schuetze. It's a wonderful book. I plan to jot down some notes here from time to time.

The Chap. 3 (Dictionaries and Tolerant Retrieval) is about data structures for storing terms, and spelling correction/suggestion.
  • A simple way to store terms is in a binary search tree.
  • If the terms keep changing (additions/deletions), use a B-tree instead.
Wild-card queries need special data structures.
  • For queries like `sch*', the binary/B tree suffices.
  • For queries like `*tze', a reversed tree can be used. Comment: Start with the original term set, reverse each term, and use the usual algorithm for tree construction.
  • For queries like `sch*tze', use both the trees to get terms with matching prefix/suffix, and then intersect the two sets.
  • For general queries like `sch*zen*ger', we need other data structures.
    • Permuterm indexes: Augment each term `abc' to `abc$'. Construct a B-tree index where all rotations (abc$, $abc, c$ab, bc$a, ...) point to `abc'. Rotate the query to `sch'$zen*ger*', look in the B-tree index for `ger$sch*', get all matches. In this set, match the complete wild card expression to get correct matches. Comment: It seems that this can be done directly with the tree + reversed tree combination. What is the advantage of the permuterm index?
    • k-gram indexes: For each term `disco', add its k-grams $di, dis, isc, sco, co$ (assuming k=3) to the index. Each k-gram points to words that contain it. Given a query `sch*zen*ger', use the query `$sc AND sch AND zen AND ger AND er$' to get matches. In this set, match the complete wild card expression to get correct matches. Comment: All matches for the Boolean query need not be correct; e.g. `ded*' gives `$de AND ded' which matches `deluded', which is not a match for the original wild-card expression.
Spelling correction requires a notion of closeness between strings, and a way to choose the best one among nearby strings.
  • Closeness between strings: This is measured in terms of edit distance or Levenshtein distance, which is computed using dynamic programming.
  • Finding the nearest strings
    • One simple way is to look through all terms in the dictionary, and compute the edit distance to each, and take the closest ones.
    • When the dictionary is big, assume the first character is correct and then look. Or, consider all rotations of the query, and look for a fixed size prefix of each rotation in a permuterm index, and collect all the terms found. Or, consider all k-grams of the query, look for them in a k-gram index, and intersect the postings lists (which contain terms, btw).
    • We can be tolerant and say "I don't need all k-grams to match" (which is what an intersection of posting lists does). So, we could say e.g. "I want at least 2 k-grams to match". For this, go through the posting lists and for each term, compare its set of k-grams with the k-grams of the query. More generally, use the Jaccard coefficient between the two sets of k-grams (of the term in the postings list, and the query) to decide whether to keep the term or not.
    • All the above methods treat each query term in isolation. For context-sensitive spelling correction, do the following. Find the nearest strings for each query term in isolation (as explained above). Try all combinations of the candidates for the different query terms. By `try', we mean query the index with each combination of terms, and rank them based on the number of document matched (highest first). Comment: The set of candidates for each query term can be pruned by `try'ing them too. Also, the pruning can be done stage-wise, i.e. if the query is `were eegles dare', first get candidates for `were' and prune to get {`were', `where', `wire'}. Then get candidates for each of {`were eegles', `where eegles', `wire eegles'} and prune to get {`were eagles', `where eagles', ...). Finally get candidates  for each of {`were eagles dare', `where eagles dare', ...} and prune to get the final list.
  • Phonetic closeness between strings: This is usually measured using Soundex algorithms. The basic idea is as follows. Hash every term into a 4-character string and build an inverted index for that (postings are the terms). Hash the query too, and search in the index. An example of a hash function is:
    • Retain the first letter. Change AEIOUHWY->0, BFPV->1, CGJKQSXZ->2, DT->3, L->4, MN->5, R->6. Compress consecutive identical digits to one. Then remove 0s, and return the first 4 positions (padded with 0 if required). For example, Manning -> M5055052 -> M505052 -> M5552 -> M555. Comment: It seems that Soundex is not a very good idea in general, especially for non-European languages/scripts.
  • Probabilistic models for spelling correction by Toutanova and Moore (2002) are the state of the art, and include ways to model edit distance, phonetic similarity, closeness on the keyboard, and data from popular spelling mistakes.

Wednesday, December 28, 2011

I recently started reading the book Introduction to Information Retrieval by Manning, Raghavan and Schuetze. It's a wonderful book. I plan to jot down some notes here from time to time.

I am in the Chap. 4 right now, on Index Construction.
  • The basic idea is as follows: Break your text into terms. Get a stream of <term, docID> pairs. Sort them on term first and then on docID. Add the terms to a dictionary. For each term, add the docIDs to a postings list (sorted by docID). The inverted index is ready.
  • For larger document collections, use Blocked Sort-Based Indexing (BSBI): Break the data into chunks that can fit in memory. Then do the above for each chunk. Finally, merge the chunk indexes. [Comment: If you are using termIDs instead of terms, you might have to do an initial pass over the data to construct the dictionary. Alternatively, augment an existing dictionary when handling each successive chunk.]
  • When the vocabulary is too large to fit in memory, use Single-Pass In-Memory Indexing (SPIMI): Similar to BSBI, but uses terms instead of termIDs, so that when the merge is done, the terms are comparable. Also, instead of creating a stream of <term, docID> pairs, maintain a dynamically allocated postings list for each term, and add new occurrences to that. Also, all chunk data structures are compressed before being written to disk.
  • When everything is too large, use Distributed Indexing (using MapReduce): In the Map Phase, get the <term, docID> pairs. The framework sorts this for you. In the Reduce phase, create the postings list. Note: The output of Map is segmented as e.g. [a-g], [h-l],[m-r],[t-z]. One segment (say [a-g]) of all Mapper outputs is sent to one Reducer. This way, that Reducer can build the complete postings lists for all terms in its segment.
When the data keeps changing, use Dynamic Indexing.
  • A simple solution is: reconstruct the index periodically.
  • If changes need to be seen immediately, use an auxiliary index. Queries hit both indexes, and the results are "combined". When the aux becomes too large, merge it with the main index. Comment: I did not understand the merging process described in the book. Given a single index file containing all postings, why do we need T/n merges?
Other flavors of indexes
  • With positional information: <termID, docID, (pos1, pos2,...)>.
  • With compression: store only gaps between docIDs (assumes sorted posting list).
  • With Ranking information: docIDs in order of relevance to term. Comment: Complicates posting list updates---cannot simply append new documents.
  • With access control: Represent each doc by the users who may access it. Invert this corpus to get a postings list per user. Intersect this with the result list for queries from that user.

Thursday, December 9, 2010

Paper notes - Dual Decomposition for Parsing with Non-Projective Head Automata

Koo, Rush, Collins, Jaakkola, Sontag. EMNLP 2010.

Problem: Non-projective head automata (I dont know this) parsing - building a parse tree for a sentence, using annotated data (sentences and their parse trees).

Contribution: A dual decomposition formulation of the problem. Leads to efficient algorithms based on minimum spanning tree (MST) algorithms and dynamic programming.

TODO : Got stuck in understanding the basics of the optimization and algorithms involved. Will get back to this later.

Some of the things to look up -
  • Head automata; parsing
  • Dual decomposition, Lagrangian relaxation - in combinatorial optimization
  • LP/ILP solvers
  • MST based optimization
  • NP-hard/complete - practice judging hardness of problems

Paper notes - Beyong NomBank: A Study of Implicit Arguments for Nominal Predicates

Gerber and Chai. ACL 2010

Problem: (Unclear to me) Identify arguments for the predicates in a sentence, even when they are implicit (having been mentioned earlier, in preceding sentences).

Contribution:
  • They have introduced a new problem. Earlier only explicit arguments were considered and their recognition was measured.
  • They have annotated data for the new problem and made it available as a resource for the community. Also, they established a baseline for future work.
Learning points
  • [IMP] Start introduction with a motivating example, that immediately elucidates the problem cleanly, and clarifies differences with existing problems/methods.
  • My ShoBha work also introduces a new problem; this might be a good model paper to emulate for my draft.
  • Introduction is short, crisp and has 3 parts - motivating example, "what is the problem" and "what is our contribution".
  • A whole section devoted to the manual efforts of annotation and resource building. We should do this for our work on the Wikipedia data.
  • Insightful comments and statistics about the data (especially those that are pertinent to the problem on hand).
  • Wherever annotation as used, Cohen's kappa coefficient (Cohen, 1960) was mentioned.
  • A careful design of features and detailed analysis using - (1) Floating forward feature selection (2) Grid search (3) Feature classes
  • Some packages used - (1) LibLinear's logistic regression solver (for analyzing feature classes) (2) OpenNLP coreference identification
  • Choose a reasonable baseline (possible based on some heuristic)
  • Look at old papers for the evaluation methodology that is prevalent for this/similar problem/s.
  • Dice coefficient for measuring performance. All results were reported with statistical significance, using two-tailed bootstrap method (Efron and Tibshirani, 1993).
  • Ablation Study (in the 'Discussion' section) w.r.t. the features.
  • Error analysis - an example when it failed, and why did it fail.
  • Success analysis - an example when it worked, and why.

Paper notes - Reinforcement Learning for mapping instructions to actions

Branavan, Chen, Luke, Barzilay. ACL 2009

Problem: Given a set of text instructions, choose a sequence of actions that carries out the instructions. For example, "Click Start, point to search, and then click for files and folders. In the search results dialog box, on the tools menu, click folder options..."

Contribution: Problem already attacked in supervised setting. They introduce reinforcement learning setting (assume it can be known whether the actions were successful or not).

Minus:
  • problem old, reinforcement setting old, algorithm (policy gradient) old, results worse than supervised case.
Plus:
  • Neat and comprehensive representation of instruction, action, environment (where actions are taken).
  • Simple log-linear model for distributions - p(x) = \exp{\theta \cdot \phi(x)}/Z. (Estimate \theta.)
  • Lot of work in designing features (4400 feature for one application, and 8000+ for the other).
  • Lot of work in designing reward function for reinforcement.
  • Policy gradient (Sutton et al., 2000) algorithm for learning; niceties there too.
  • Testing the fundamental hypothesis - Analysis of real impact of text on the task (checking if it is work due to information other than the text, by measuring certain stats and by cleverly removing text info).
  • Baseline analysis - (a) Show that naive baselines do bad (so non-trivial task) (b) Show that supervised baseline is not great ('hard' task) (c) Finer analysis - cause of hardness (d) Mixing methods to measure partial impact of each method (a different kind of 'ablation' study)
  • Always report statistical significance (sign test)

Sunday, December 21, 2008

FIRE 2008 at Kolkata

FIRE (Forum For Information Retrieval Evaluation) Workshop 2008 at Kolkata, Dec 13-15

Talks
Donna Harman - failure analysis
Xerox - Nicola Cancedda - CCA for EU langs
Kalervo Jaervelin - Finland - morph analysis
Noriko Kando, Tatsuya Sakai - NTCIR, Galaxy of Words - interaction in IR
Doug Ouard - Univ. of Maryland
Carol Peters - CLEF
Mark Sanderson - Diversity in results (evaluation using clustering)
CLIA (Cross-Lingual Information Access) - an-India project (IITB/K, IIITH,ISI,JU,AU) - building IR for Indian lang + building resources for that (dic,corp,Ont,Rules etc.)

Runs
JHU - n-grams,skipgrams, lang-indep
Univ. of Neuchatel (Jacques Savoy) (recommended reading by Donna Harman) - various techniques - Okapi,BM25, DFR (prob), LM (stat), tf.idf, data fusion

Others
Measures - MAP is the most preferred, Prec. vs. Recall also used, Performance never discussed
People - Manoj Chinnakotla, Vishal Vachnani, Ashish Almeida, Pavitro Mitra (IITKgp)

Upcoming confs
NE workshop at ACL-IJCNLP - NE task - Dates - Task details - Jan 31 - Paper submsn - May 01 - acl-ijcnlp-2009.org/workshops/NEWS2009
Workshop in CLIA - talks and papers - search.iiit.ac.in/CLIA2009 - Dates: Mar 06 - paper subm
Discourse Anaphora and Anaphora Resolution Colloquium (DAARC2009) - Nov 5-6 2009, Goa - www.au-kbc.org/daarc2009 - Dates: April 25 - pap subm,

Monday, March 24, 2008

IIIT Hyd's work

Indian language font/script related
- identifying language of given text
- identifying encoding of given text
- developing a metaformat for uniformity
- converting from one encoding to another
Techniques used - TF*IDF, Glyph assimilation, IT3 (phonetic transliteration scheme)


Language and encoding identification (Anil Kumar Singh)
- choices -> (1) What kind of language modeling should be used for representing training texts? (2) Which similarity measure should be used for comparing the models obtained from the texts?
- Models -> (1) n-grams model
- Similarity measures -> (1) out of rank - sum[for all n-grams in test data: diff(rank of n-gram in test data,rank in training data)](2) mutual cross entropy (3) translator approaches (4) compare profiles of n-gram frequencies (5)
- orthographical features (based on letter sequences and frequencies)
- add-k smoothing
- pruning
- Monte Carlo sampling
- cross entropy
- Prediction by partial matching (Teahan and Harper 2001)
- Cavnar -> top 300 n-grams indicate language of text, bottom n-grams indicate topic of text


POS tagging for Gujarati using CRF's
- 26 POS tags, 600 tagged sentences, 5000 untagged sentences, 10000 training corpus (??)
- use CRF methods for tagging (why?)
- errors attributed to not enough training data

Similarity measures for sentence alignment
- weighted sentence length (charc,wordc,sig) -> Poisson (how?)
- word correspondence (based on distribution of words in the language??)
- NPC matching
- common word count
- syno/hyper nym intersection (using WordNet) -> for more abstract similarity measurement
- F-measure??

Friday, February 15, 2008

Machine translation applications - first findings

Users
Home users
  1. Automatically translate web pages
  2. Translate chat
Organizational users (companies, government)
  1. Classifying documents as “needing human translation” or “not”; estimating effort needed for translation
  2. Localization support [e.g. for instruction manuals]
  3. Translation of email, documents, reports etc.
Professional users (translators)
  1. Support tools for translators who do post-editing
Unclassified
1. Spoken language translation (where is it used?)
Languages
  1. From European languages to Chinese/Japanese/Arabic and vice versa.
  2. From one European language to another
  3. Other languages include - Korean
Comment
In general, even the best MT systems in use today are mainly useful to get a general idea/gist of the text. Grammar and preservation of meaning can not be guaranteed. The main use cases for such limited functionality could be -
  • Automatic translation of websites, but only where the objective is doing something on the website [e.g. booking tickets/hotel rooms, shopping for goods which shoppers already know about], or getting some information. It is not suited for reading articles or literary works. The sentences should be small (and hence easier to translate). [e.g. titles of menus, small descriptions of the services offered by the site etc., news snippets]
  • Tools that assist human translators [e.g. localization support tools].
  • Chatting
  • Online service for naive users – for applications similar to the above, except that the text is in some other system where there is no translation feature provided [e.g. where the chat client does not provide translation].
Applications of MT system components
  1. Spell-check, grammar-check
  2. Dictionary/thesaurus – mono and bi-lingual
  3. Multi-lingual search (thematic search, query translation)
Applications where MT is a component
  1. Speech translation
  2. OCR