Python compute_auc Examples

Example #1

def weight_analysis(verbose=0, stack_option='s'):
  logging.info('starting ensemble weight analysis')

  stack = STACK if stack_option == 's' else MODELS

  pool = multiprocessing.Pool(processes=4)
  drivers = settings.DRIVER_IDS#[:1000]
  CUTOFF = -1
  results = pool.map(
      compute_weights,
      map(lambda x: (x, verbose, stack_option), drivers)
  )

  predictions = {}
  for i, get_data, model, _ in stack:
    predictions[i] = np.array(list(itertools.chain(*[r[1][i] for r in results])))
  testY = list(itertools.chain(*[r[2] for r in results]))

  model_names = [
      ('%s.%s.%s' % (get_data.func_name, model.__name__, i), i)
      for i, get_data, model, repeat in stack
  ]
  model_names.sort(key=lambda x: x[0])
  keys = [x[1] for x in model_names]
  model_names = [x[0] for x in model_names]

  lasso = Lasso(alpha=0.0, positive=True)
  trainX = []
  for row_id in xrange(len(testY)):
    train_row = [predictions[i][row_id] for i in keys]
    trainX.append(train_row)

  a, b = trainX[:CUTOFF], trainX[CUTOFF:]
  c, d = testY[:CUTOFF], testY[CUTOFF:]
  lasso.fit(a, c)
  pred = lasso.predict(b)
  pred_train = lasso.predict(a)
  #logging.info('auc: %s' % util.compute_auc(d, pred))

  logging.info('coefficients:')
  weights = {}
  for i, name in enumerate(model_names):
    logging.info('%s: %.3f' % (model_names[i], lasso.coef_[i]))
    weights[keys[i]] = lasso.coef_[i]

  logging.info('individual scores:')
  for i, key in enumerate(keys):
    logging.info('%s: %.3f' % (
        model_names[i],
        util.compute_auc(testY, predictions[key])
    ))

  logging.info('weights dictionary: %s' % weights)

  # and again in the end, so you don't have to scroll
  logging.info('------------')
  #logging.info('auc: %s' % util.compute_auc(d, pred))
  logging.info('auc train: %s' % util.compute_auc(c, pred_train))

Example #2

def train(verbose=0):
    logging.info('running ensemble')
    pool = multiprocessing.Pool(processes=4)
    drivers = settings.DRIVER_IDS  #[1000:]
    results = pool.map(run_ensemble, [(x, verbose) for x in drivers])

    predictions = np.array(list(itertools.chain(*[r[0] for r in results])))
    testY = list(itertools.chain(*[r[1] for r in results]))

    S = sum([s[-1] for s in STACK])
    logging.info(util.compute_auc(testY, predictions))

Example #3

File: ensemble.py Project: BorisLenz/kaggle-driver-telematics

def train(verbose=0):
  logging.info('running ensemble')
  pool = multiprocessing.Pool(processes=4)
  drivers = settings.DRIVER_IDS #[1000:]
  results = pool.map(
      run_ensemble,
      map(lambda x: (x, verbose), drivers)
  )

  predictions = np.array(list(itertools.chain(*[r[0] for r in results])))
  testY = list(itertools.chain(*[r[1] for r in results]))

  S = sum([s[-1] for s in STACK])
  logging.info(util.compute_auc(testY, predictions))

Example #4

import logging
import multiprocessing
import itertools

import numpy as np

from model_run import run_model, test_model
import model_run
import model_def
import settings
import util

logging.root.setLevel(level=logging.INFO)
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s')

if __name__ == '__main__':
    logging.info('starting main.py')

    #run_model((100, 203, model_def.Model_GBC, model_run.get_data_accel_v2_svd, 1)); raise Exception

    pool = multiprocessing.Pool(processes=1)
    results = pool.map(
        run_model,
        [(100, x, model_def.Model_LR2, model_run.get_data_movements_accel, 1)
         for x in settings.DRIVER_IDS[:10]])
    predictions = np.array(list(itertools.chain(*[r[0] for r in results])))
    testY = list(itertools.chain(*[r[-1] for r in results]))
    logging.info(util.compute_auc(testY, predictions))

Example #5

File: main.py Project: BorisLenz/kaggle-driver-telematics

import logging
import multiprocessing
import itertools

import numpy as np

from model_run import run_model, test_model
import model_run
import model_def
import settings
import util

logging.root.setLevel(level=logging.INFO)
logging.basicConfig(format='%(asctime)s : %(levelname)s : %(message)s')

if __name__ == '__main__':
  logging.info('starting main.py')

  #run_model((100, 203, model_def.Model_GBC, model_run.get_data_accel_v2_svd, 1)); raise Exception

  pool = multiprocessing.Pool(processes=1)
  results = pool.map(
      run_model,
      map(lambda x: (100, x, model_def.Model_LR2, model_run.get_data_movements_accel, 1), settings.DRIVER_IDS[:10])
  )
  predictions = np.array(list(itertools.chain(*[r[0] for r in results])))
  testY = list(itertools.chain(*[r[-1] for r in results]))
  logging.info(util.compute_auc(testY, predictions))