Diverse questions relative a cette contribution Kaggle

Bonjour Laurae,

Je m'adresse a toi en français car j'ai vu ton profil kaggle que tu étais en île de France. Moi aussi. Je suis un nouveau passionné de datascience et j’étudie des codes comme le tien afin d'apprendre. Merci de partager ainsi votre connaissance. J'ai donc qques questions concernant ton code si tu veux bien y répondre. Je suis aussi dispo par tout autre moyen de communication que tu souhaiterai.

Question1 --------------------------------------------------------------------------------------

Est ce que ton algorithme blend_proba (Stacker.py) prend en compte le cas de la multiclassification ?
Au sein de cet algorithme on a ceci a adapter en fonction de la métrique

 for i in range(len(fold_preds)): 
        if fold_preds[i]<0.0: #adapt to metric  
            fold_preds[i] = 0.0 #adapt to metric
        if fold_preds[i]>1.0: #adapt to metric 
            fold_preds[i] = 1.0 #adapt to metric

N'est ce pas plutôt a adapter en fonction en fonction du fait qu'on fait une classification binaire, multiclassification ou régression ?

Ce que je comprend la c'est que vu que tu va utiliser des "regressor" pour faire une classification binaire, tu corrige les sorties de la classification binaire de cette façon.

Pour moi sur un problème de régression ce ne serait pas nécessaire et que faire sur un problème de multiclassification ?

Connais tu ce programme : https://github.com/MLWave/Kaggle-Ensemble-Guide/blob/master/blend_proba.py

Il fait la meme chose que le tien mais j'arrive pas a le faire fonctionner sous Python 3.5 : http://stackoverflow.com/questions/39687959/error-when-converting-form-python-2-to-python-3

Question2 --------------------------------------------------------------------------------------

As tu des références sur cette technique qui te permet d'utiliser des regressor comme classifier stp ?

Question3 --------------------------------------------------------------------------------------

J'ai regardé sur le net pour voir si il existait des stacking de plus de 3 levels et je n'en ai pas trouvé d'ou ma question pourquoi on ne va pas sur plus de 3 niveaux avec du stacking ? des problèmes de sur apprentissage ? Si oui pourquoi ?

Question4 --------------------------------------------------------------------------------------

def log_loss_func(weights):
    ''' scipy minimize will pass the weights as a numpy array '''
    final_prediction = 0
    for weight, prediction in zip(weights, predictions):
            final_prediction += weight*prediction

    return log_loss(Y_testing, final_prediction) 

#the algorithms need a starting value, right not we chose 0.5 for all weights
#its better to choose many random starting points and run minimize a few times
starting_values = np.ones(len(predictions))/(len(predictions))

#adding constraints  and a different solver 
cons = ({'type':'eq','fun':lambda w: 1-sum(w)})

#our weights are bound between 0 and 1
bounds = [(0,1)]*len(predictions)

res = minimize(log_loss_func, starting_values, method='SLSQP', bounds=bounds, constraints=cons)
#res = minimize(log_loss_func, starting_values, method='SLSQP')

print('Ensamble Score: {best_score}'.format(best_score=res['fun']))
print('Best Weights: {weights}'.format(weights=res['x']))

Ton bout de code ci dessus permet de calculer les poids en minimisant le log_loss et résoud le problème d'optimisation ci dessous:

op f(x)
    x =[a,b,c,......,n]
    0 <= xi <=1
    sum(x) = 1

Mon problème concerne le cas ou on veux utiliser le roc_auc_score et donc l'optimiser et non le minimiser. comment traduire le fait qu'on veuille optimiser et non minimiser

J'ai assayé les options suivantes et ce qui est surprenant j'ai la même sortie en terme de poids:

Essai_1

def roc_func(weights):
    ''' scipy minimize will pass the weights as a numpy array '''
    final_prediction = 0
    for weight, prediction in zip(weights, predictions):
            final_prediction += weight*prediction

    return roc_auc_score(Y_testing, final_prediction)

Essai_2 (en inversant la fonction précédente et en appliquant minimize, je me dit qu'on fait une maximisation (comme avec hyperopt))

def roc_func(weights):
    ''' scipy minimize will pass the weights as a numpy array '''
    final_prediction = 0
    for weight, prediction in zip(weights, predictions):
            final_prediction += weight*prediction

    return - roc_auc_score(Y_testing, final_prediction)

Essai_3

def roc_func(weights):
    ''' scipy minimize will pass the weights as a numpy array '''
    final_prediction = 0
    for weight, prediction in zip(weights, predictions):
            final_prediction += weight*prediction

    return 1 - roc_auc_score(Y_testing, final_prediction)

Laurae2 / Santander

Diverse questions relative a cette contribution Kaggle #2