In [11]:

    

import IPython
import numpy as np
import pandas as pd
from tsa.science import numpy_ext as npx

from sklearn import metrics, cross_validation
from sklearn import linear_model

from tsa.lib import datetime_extra
from tsa.science.plot import plt, figure_path, distinct_styles, ticker
from tsa.science import features, models, timeseries
from tsa.science.corpora import MulticlassCorpus
from tsa.models import Source, Document, create_session


    

In [15]:

    

full_corpus = MulticlassCorpus(Source.from_name('sb5b', labeled_only=True))
full_corpus.apply_labelfunc(lambda doc: doc.label)

# ngrams_corpus = MulticlassCorpus.subset()
ngrams_features = full_corpus.extract_features(lambda doc: doc.document,
                                               features.ngrams,
                                               ngram_max=2, min_df=2, max_df=1.0)
cooccurrence_features = full_corpus.extract_features(lambda doc: doc.document,
                                                     features.cooccurrences,
                                                     min_df=3, max_df=0.99)
all_features = np.concatenate((ngrams_features, cooccurrence_features))


    

    




---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-15-426f0788b5d6> in <module>()
      9                                                      features.cooccurrences,
     10                                                      min_df=3, max_df=0.99)
---> 11 all_features = np.concatenate(ngrams_features, cooccurrence_features)

TypeError: only length-1 arrays can be converted to Python scalars

In [6]:

    

polar_classes = [full_corpus.class_lookup[label] for label in ['For', 'Against']]
polar_indices = np.in1d(full_corpus.y, polar_classes)
polar_corpus = full_corpus.subset(rows=polar_indices)


    

In [12]:

    

def corpus_mean_accuracy(corpus, penalty='l2', test_size=0.1, n_iter=10):
    folds = cross_validation.StratifiedShuffleSplit(corpus.y, test_size=test_size, n_iter=n_iter)
    accuracies = []
    for fold_index, (train_indices, test_indices) in enumerate(folds):
        train_corpus = corpus.subset(train_indices)
        test_corpus = corpus.subset(test_indices)
    
        model = linear_model.LogisticRegression(fit_intercept=False, penalty=penalty)
        model.fit(train_corpus.X, train_corpus.y)
        pred_y = model.predict(test_corpus.X)
        accuracy = metrics.accuracy_score(test_corpus.y, pred_y)
        accuracies += [accuracy]
    return np.mean(accuracies)


    

In [19]:

    

feature_sets = [
                ('Both', all_features),
                ('Ngrams', ngrams_features),
                ('Co-occurrences', cooccurrence_features),
               ]
for name, selected_features in feature_sets:
    accuracy = corpus_mean_accuracy(polar_corpus.subset(features=selected_features))
    # .replace('%', '\\%'),
    print '{:s} & {:.2f}\\% \\\\ % {:d} features'.format(name, accuracy * 100, selected_features.size)


    

    




Both & 96.02\% \\ % 219152 features
Ngrams & 95.94\% \\ % 44456 features
Co-occurrences & 95.47\% \\ % 174696 features

In [14]:

    

cooccurrence_features.size, ngrams_features.size


    

    
Out[14]:





(174696, 44456)