<jupyter_start><jupyter_text>UNIVERSIDAD NACIONAL DE INGENIERIA  Inteligencia Artificial  Proyecto Final Parte 01 - Extracción de características    <NAME> : <EMAIL>  <NAME> : <EMAIL>     <NAME>  : <EMAIL>     Docente    : <NAME>   -------------------------------- **Resumen  :**  Los usuarios de una línea telefónica son propensos a portar a otro operador, por ende es necesario saber previamente si esto va a suceder para que la empresa pueda emplear medidas para que esto no suceda. El proyecto presente tiene dos objetivos principales: la clasificación usuarios que portan o no y la interpretación del modelo para identificar las razones especificas de la portabilidad de los clientes.<jupyter_code><jupyter_output><empty_output><jupyter_text>--------------------------   1. INDICE* [1. INDICE](1)* [2. DATASET](2)* [3. MÉTRICA](3)* [4. IMPORTANDO LIBRERIAS](4)* [5. CARGAR DATA](5)* [6. DATA EXPLORATION and FEATURES CREATION](6)* [7. PROBANDO PCA PARA REDUCIR LOS FEATURES](7)* [8. USANDO LOS FEATURES HALLADOS EN EL ARCHIVO PROYECTO_FINAL_02](8)* [9. CONTINUAR ARCHIVO PROYECTO_FINAL_02](9)   2. DATASET Consta de 6 archivos- TRAIN_TARGET : 2 variables- TRAIN_FUENTE_PLANTAPOST : 10 variables - TRAIN_FUENTE_EQUIPOS : 18 variables- TRAIN_FUENTE_DATOS : 10 variables- TRAIN_FUENTE_VOZ : 29 variables- TRAIN_FUENTE_APLICACIONES : 14 variables- TRAIN_FUENTE_CONSULTA_PREV_PORTA : 3 variables   3. METRICA La métrica de evaluación usaremos es el AUC, para entenderlo primero haremos unas definiciones:  CURVA ROC Una **curva ROC (curva de característica operativa del recepto)** es un gráfico que muestra el rendimiento de un modelo de clasificación en todos los umbrales de clasificación. Esta curva representa dos parámetros:- Tasa de verdaderos positivos- Tasas de falsos positivos **Tasa de verdaderos positivos (TPR)** es sinónimo de exhaustividad y, por lo tanto, se define de la siguiente manera:\begin{equation}TPR = \frac{VP}{VP+FN}\end{equation} **Tasa de falsos positivos (FPR)**  se define de la siguiente manera:\begin{equation}FPR = \frac{FP}{FP+VN}\end{equation} Una curva ROC representa TPR frente a FPR en diferentes umbrales de clasificación. Reducir el umbral de clasificación clasifica más elementos como positivos, por lo que aumentarán tanto los falsos positivos como los verdaderos positivos. En la siguiente figura, se muestra una curva ROC típica.Para calcular los puntos en una curva ROC, podríamos evaluar un modelo de regresión logística muchas veces con diferentes umbrales de clasificación, pero esto es ineficiente. Afortunadamente, existe un algoritmo eficiente basado en ordenamiento que puede brindarnos esta información, denominado AUC.<jupyter_code>from PIL import Image
Image.open('/home/liiarpi/Downloads/DATA/MOVISTAR/PAPER/imagenes/roc.png')<jupyter_output><empty_output><jupyter_text>AUC : Área bajo la curva ROC  **AUC** significa "área bajo la curva ROC". Esto significa que el AUC mide toda el área bidimensional por debajo de la curva ROC completa (piensa en un cálculo integral) de (0,0) a (1,1).<jupyter_code>Image.open('/home/liiarpi/Downloads/DATA/MOVISTAR/PAPER/imagenes/auc.png')<jupyter_output><empty_output><jupyter_text>El AUC proporciona una medición agregada del rendimiento en todos los umbrales de clasificación posibles. Una forma de interpretar el AUC es como la probabilidad de que el modelo clasifique un ejemplo positivo aleatorio más alto que un ejemplo negativo aleatorio. Observa, a modo de ilustración, los siguientes ejemplos, que están ordenados de izquierda a derecha en orden ascendente con respecto a las predicciones de regresión logística:El AUC representa la probabilidad de que un ejemplo aleatorio positivo (verde) se posicione a la derecha de un ejemplo aleatorio negativo (rojo).El AUC oscila en valor del 0 al 1. Un modelo cuyas predicciones son un 100% incorrectas tiene un AUC de 0.0; otro cuyas predicciones son un 100% correctas tiene un AUC de 1.0.<jupyter_code>Image.open('/home/liiarpi/Downloads/DATA/MOVISTAR/PAPER/imagenes/cuadri.png')<jupyter_output><empty_output><jupyter_text>**Razones por la cual usamos AUC como métrica :**- El AUC es **invariable con respecto a la escala.** Mide qué tan bien se clasifican las predicciones, en lugar de sus valores absolutos.- El AUC es **invariable con respecto al umbral de clasificación.** Mide la calidad de las predicciones del modelo, sin tener en cuenta qué umbral de clasificación se elige.   4. IMPORTAR LIBRERIAS<jupyter_code>from librerias3 import *
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
import pandas as pd
import numpy as np
import matplotlib.pyplot as pltd
import seaborn as sns
import gc
from sklearn.model_selection import train_test_split
import lightgbm as lgb
import warnings
warnings.filterwarnings('ignore')<jupyter_output><empty_output><jupyter_text>5. CARGAR DATA<jupyter_code>train_path='/home/liiarpi/Downloads/DATA/MOVISTAR/DATA/TRAIN/'
target=pd.read_csv(train_path+'TRAIN_TARGET.txt',sep='|')
tfa   =pd.read_csv(train_path+'TRAIN_FUENTE_APLICACIONES.txt',sep='|',parse_dates=['PERIODO'])
tfc   =pd.read_csv(train_path+'TRAIN_FUENTE_CONSULTA_PREV_PORTA.txt',sep='|',parse_dates=['PERIODO'])
tfd   =pd.read_csv(train_path+'TRAIN_FUENTE_DATOS.txt',sep='|',parse_dates=['PERIODO'])
tfe   =pd.read_csv(train_path+'TRAIN_FUENTE_EQUIPOS.txt',sep='|',parse_dates=['PERIODO'])
tfv   =pd.read_csv(train_path+'TRAIN_FUENTE_VOZ.txt',sep='|',parse_dates=['PERIODO'])
tpp   =pd.read_csv(train_path+'TRAIN_PLANTAPOST.txt',sep='|',parse_dates=['PERIODO'])
target.head()
tfc.head()
names=tfa.columns.values 
found_index = np.in1d(names, ['ID_CLIENTE','PERIODO']).nonzero()[0]
names = np.delete(names, found_index)+'_mean'
names<jupyter_output><empty_output><jupyter_text>6. Data Exploration and Feature Creation<jupyter_code>def procesar_2(names,df):
    x= df[names]
    names=x.columns.values
    for i in range(0,x.shape[1]):
        namecolumn=names[i]
        x['alta_'+namecolumn]=(x[namecolumn]>(x[namecolumn].mean()+x[namecolumn].std()))
        x['media_'+namecolumn]=(x[namecolumn]<=(x[namecolumn].mean()+x[namecolumn].std()))
        x['media_'+namecolumn]=x['media_'+namecolumn]&(x[namecolumn]>=(x[namecolumn].mean()-x[namecolumn].std()))
        x['baja_'+namecolumn]=(x[namecolumn]<=(x[namecolumn].mean()-x[namecolumn].std()))
        x=x.drop([namecolumn],axis=1)
    x=x.astype('float')
    return x
def agg_numeric(df, group_var):
    # Remove id variables other than grouping variable
    for col in df:
        if col != group_var and 'ID_CLIENTE' in col:
            df = df.drop(columns = col)
            
    group_ids = df[group_var]
    numeric_df = df.select_dtypes('number')
    numeric_df[group_var] = group_ids

    # Group by the specified variable and calculate the statistics
    agg = numeric_df.groupby(group_var).agg(['count', 'mean', 'max', 'min', 'sum']).reset_index()

    # Need to create new column names
    columns = [group_var]

    # Iterate through the variables names
    for var in agg.columns.levels[0]:
        # Skip the grouping variable
        if var != group_var:
            # Iterate through the stat names
            for stat in agg.columns.levels[1][:-1]:
                # Make a new column name for the variable and stat
                columns.append('%s_%s' % (var, stat))

    agg.columns = columns
    print('NUEVOS FEATURES CREADOS')
    return agg
def agg_numeric2(df, group_var):
    # Remove id variables other than grouping variable
    for col in df:
        if col != group_var and 'ID_CLIENTE' in col:
            df = df.drop(columns = col)
            
    group_ids = df[group_var]
    numeric_df = df.select_dtypes('number')
    numeric_df[group_var] = group_ids

    # Group by the specified variable and calculate the statistics
    agg = numeric_df.groupby(group_var).agg(['mean']).reset_index()

    # Need to create new column names
    columns = [group_var]

    # Iterate through the variables names
    for var in agg.columns.levels[0]:
        # Skip the grouping variable
        if var != group_var:
            # Iterate through the stat names
            for stat in agg.columns.levels[1][:-1]:
                # Make a new column name for the variable and stat
                columns.append('%s_%s' % (var, stat))
    agg.columns = columns
    print('NUEVOS FEATURES CREADOS')
    return agg
def procesar_1(path,name):
    df=pd.read_csv(path+name,sep='|', parse_dates=['PERIODO'])
    print(df.shape)
    #names=df.columns.values 
    #found_index = np.in1d(names, ['ID_CLIENTE','PERIODO']).nonzero()[0]
    #names = np.delete(names, found_index)+'_mean'
    #names2=df.columns.values
    #found_index2 = np.in1d(names2, ['PERIODO']).nonzero()[0]
    #names2 = np.delete(names2, found_index2)
    
    #df_date = agg_numeric2(df[['ID_CLIENTE','PERIODO']], group_var = 'ID_CLIENTE')
    
    date_attr = ['Year', 'Month', 'Week', 'Day', 'Dayofweek', 'Dayofyear', 'Is_month_end',
    'Is_month_start', 'Is_quarter_end', 'Is_quarter_start', 'Is_year_end', 'Is_year_start']
    for n in date_attr:
        a = getattr(df['PERIODO'].dt, n.lower())
        #a[a==np.NaN]=0
        a[(1-np.isnan(a))>0.0001]=0
        a[a==np.Inf]=0
        a[a==-np.Inf]=0
        df['PERIODO_' + n]=a.astype(float)
        # 2. Agregamos una columan con una representación numérica de la fecha
        df['PERIODO_elapsed'] = df['PERIODO'].astype(np.int64) // 10 ** 9

    # 3. Eliminamos la variable date
    df.drop('PERIODO', axis=1, inplace=True)
    
    names3=df.columns.values
    found_index3 = np.in1d(names3, ['ID_CLIENTE']).nonzero()[0]
    names3 = np.delete(names3, found_index3)+'_mean'
    
    #VARIABLES OBJECT FLOAT
    for n,col in df.items():
        if not pd.api.types.is_numeric_dtype(col) and n != 'ID_CLIENTE': 
            df[n] = col.astype('category')
    
    for n,col in df.items()  : 
        if pd.api.types.is_categorical_dtype(col) and n != 'ID_CLIENTE':
            df[n] = col.cat.codes+1 
    
    names = df.columns.values 
    aa=df.isna().sum() / len(df) # % de data faltante
    for i in range (0,aa.shape[0]):
        if(aa[i]>0):
            print('DATA FALTANTE -',names[i])
            df[str(names[i])]=df[str(names[i])].fillna(df[str(names[i])].mean())
   
    df = agg_numeric(df, group_var = 'ID_CLIENTE')
    
    #df = agg_numeric(df[names2], group_var = 'ID_CLIENTE')
    #df = pd.merge(df,df_date, on='ID_CLIENTE', how='left')
    #print(df.columns.values)
    #print(names3)
    df2 =procesar_2(names3,df)
  
    df = pd.concat([df,df2], axis=1)
    
    print(df.shape)
    
    return df
a=[2,3,np.NaN,np.Inf]
a[a==np.NaN]=0
a

train_path='/home/liiarpi/Downloads/DATA/MOVISTAR/DATA/TRAIN/'
df=procesar_1(train_path,'TRAIN_FUENTE_CONSULTA_PREV_PORTA.txt')

train_path='/home/liiarpi/Downloads/DATA/MOVISTAR/DATA/TRAIN/'
df=procesar_1(train_path,'TRAIN_FUENTE_VOZ.txt')
path='/home/liiarpi/Downloads/DATA/MOVISTAR'
pathtrain=path+'/DATA/TRAIN/'
pathtest =path+'/DATA/TEST/'
pathguardartrain=path+'/NEW_DATA3/NEW_TRAIN/'
pathguardartest =path+'/NEW_DATA3/NEW_TEST/'

def transformar(pathorigen,path,name):
    df=procesar_1(pathorigen,name+'.txt')
    names = df.columns.values
    df.to_csv(path+name+'.csv',index=None)
    
    
transformar(pathtrain,pathguardartrain,'TRAIN_FUENTE_APLICACIONES')
transformar(pathtrain,pathguardartrain,'TRAIN_FUENTE_CONSULTA_PREV_PORTA')
transformar(pathtrain,pathguardartrain,'TRAIN_FUENTE_DATOS')
transformar(pathtrain,pathguardartrain,'TRAIN_FUENTE_EQUIPOS')
transformar(pathtrain,pathguardartrain,'TRAIN_FUENTE_VOZ')
transformar(pathtrain,pathguardartrain,'TRAIN_PLANTAPOST')
transformar(pathtest,pathguardartest,'TEST_FUENTE_APLICACIONES')
transformar(pathtest,pathguardartest,'TEST_FUENTE_CONSULTA_PREV_PORTA')
transformar(pathtest,pathguardartest,'TEST_FUENTE_DATOS')
transformar(pathtest,pathguardartest,'TEST_FUENTE_EQUIPOS')
transformar(pathtest,pathguardartest,'TEST_FUENTE_VOZ')
transformar(pathtest,pathguardartest,'TEST_PLANTAPOST')

train_path='/home/liiarpi/Downloads/DATA/MOVISTAR/NEW_DATA3/NEW_TRAIN/'
target=pd.read_csv('/home/liiarpi/Downloads/DATA/MOVISTAR/DATA/TRAIN/TRAIN_TARGET.txt',sep='|')
tfa=pd.read_csv(train_path+'TRAIN_FUENTE_APLICACIONES.csv')
tfc=pd.read_csv(train_path+'TRAIN_FUENTE_CONSULTA_PREV_PORTA.csv')
tfd=pd.read_csv(train_path+'TRAIN_FUENTE_DATOS.csv')
tfe=pd.read_csv(train_path+'TRAIN_FUENTE_EQUIPOS.csv')
tfv=pd.read_csv(train_path+'TRAIN_FUENTE_VOZ.csv')
tpp=pd.read_csv(train_path+'TRAIN_PLANTAPOST.csv')
TrainData = pd.merge(target, tfa, how='left')
TrainData = pd.merge(TrainData, tfc, on='ID_CLIENTE', how='left')
TrainData = pd.merge(TrainData, tfd, on='ID_CLIENTE', how='left')
TrainData = pd.merge(TrainData, tfe, on='ID_CLIENTE', how='left')
TrainData = pd.merge(TrainData, tfv, on='ID_CLIENTE', how='left')
TrainData = pd.merge(TrainData, tpp, on='ID_CLIENTE', how='left')

train=pd.read_csv('Data_tratada_Train.csv',na_values=['NaN','nan',-1])
print('tamaño = ', train.shape)
# Presentamos un ejemplo (de 5 datos) del dataset
train.head()
X=train.drop(columns=['ID_CLIENTE', 'TARGET'])
y=train['TARGET']
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=7)
#X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=7)
train_data=lgb.Dataset(X_train, y_train)
test_data=lgb.Dataset(X_test, y_test, reference=train_data)
params = {
    'task': 'train',
    'boosting_type': 'gbdt',
    'objective': 'binary',
    'metric': {'auc'},
    'num_leaves': 20,
    'num_boost_round': 5000,
    'min_data_in_leaf': 50,
    'max_depth': -1,
    'verbose': -1,
    'n_jobs': -1,
    'learning_rate': 0.035
}
model = lgb.train(params,train_data,valid_sets=test_data,early_stopping_rounds=80)
a=lgb.plot_importance(model,importance_type='split',height=0.8,figsize=(18,80),grid=False,ignore_zero=False)<jupyter_output><empty_output><jupyter_text>7.PROBANDO PCA PARA REDUCIR LOS FEATURES<jupyter_code>from sklearn.decomposition import PCA
from sklearn import metrics

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_auc_score
def pcaa(a,xx,yy):
    print("PCA de %d elementos"%a)
    pca =PCA(n_components=a)
    pca.fit(xx)
    xx=pca.transform(xx)
    print('pca listo')
    print('USANDO RANDOMFOREST CLASSIFIER')
    xx_train, xx_val, yy_train, yy_val = train_test_split(xx, yy, test_size=0.2, random_state=42)
    mm = RandomForestClassifier(20, n_jobs=-1, oob_score=True,min_samples_split=10)#,max_features=10)
    mm.fit(xx_train,yy_train)
    y_train_pred = mm.predict(xx_train)
    y_val_pred = mm.predict(xx_val)
    print(f'Scores:')
    print(f'Train      = {metrics.accuracy_score(yy_train, y_train_pred):.4}')
    print(f'Validation = {metrics.accuracy_score(yy_val, y_val_pred):.4}')
    if hasattr(mm, 'oob_score_'): print(f'OOB        = {mm.oob_score_:.4}')
    print("AUC Train ",roc_auc_score(yy_train, y_train_pred))
    print("AUC Test ",roc_auc_score(yy_val, y_val_pred))
    print('USANDO SVM')
    '''
    from sklearn.svm import SVC
    model_svm = SVC(gamma='auto')
    model_svm.fit(xx_train,yy_train) 
    y_train_pred = model_svm.predict(xx_train)
    y_val_pred = model_svm.predict(xx_val)
    print("Accuracy Training Support Vector Machines:",metrics.accuracy_score(yy_train, y_train_pred))
    print("Accuracy Validation Support Vector Machines:",metrics.accuracy_score(yy_val, y_val_pred))
    print("AUC Train ",roc_auc_score(yy_train, y_train_pred))
    print("AUC Test ",roc_auc_score(yy_val, y_val_pred))'''
    
    print('USANDO LOGISTIC')
    from sklearn.linear_model import LogisticRegression
    model_logistic = LogisticRegression(random_state=0, solver='lbfgs')
    model_logistic.fit(xx_train, yy_train)
    y_train_pred = model_logistic.predict(xx_train)
    y_val_pred = model_logistic.predict(xx_val)
    print("Accuracy Training Logistic:",metrics.accuracy_score(yy_train, y_train_pred))
    print("Accuracy Validation Logistic:",metrics.accuracy_score(yy_val, y_val_pred))
    print("AUC Train ",roc_auc_score(yy_train, y_train_pred))
    print("AUC Test ",roc_auc_score(yy_val, y_val_pred))

    return mm,pca
pcaa(10,X,y)
modelo,pca_modelo=pcaa(20,X,y)
pcaa(15,X,y)<jupyter_output>PCA de 15 elementos
pca listo
USANDO RANDOMFOREST CLASSIFIER
Scores:
Train      = 0.9364
Validation = 0.8999
OOB        = 0.8962
AUC Train  0.6819642857142857
AUC Test  0.49992063492063493
USANDO SVM
USANDO LOGISTIC
Accuracy Training Logistic: 0.8793630952380952
Accuracy Validation Logistic: 0.8794761904761905
AUC Train  0.5106779100529102
AUC Test  0.5091269841269841<jupyter_text>No mejoramos el modelo de lightgbm<jupyter_code>test_path='/home/liiarpi/Downloads/DATA/MOVISTAR/NEW_DATA3/NEW_TEST/'
sfa=pd.read_csv(test_path+'TEST_FUENTE_APLICACIONES.csv')
sfc=pd.read_csv(test_path+'TEST_FUENTE_CONSULTA_PREV_PORTA.csv')
sfd=pd.read_csv(test_path+'TEST_FUENTE_DATOS.csv')
sfe=pd.read_csv(test_path+'TEST_FUENTE_EQUIPOS.csv')
sfv=pd.read_csv(test_path+'TEST_FUENTE_VOZ.csv')
spp=pd.read_csv(test_path+'TEST_PLANTAPOST.csv')
envio=pd.read_csv('/home/liiarpi/Downloads/DATA/MOVISTAR/DATA/TEST/TEST_ENVIO.txt',sep='|')
sfa=sfa.reindex(tfa.columns,axis=1)
sfc=sfc.reindex(tfc.columns,axis=1)
sfd=sfd.reindex(tfd.columns,axis=1)
sfe=sfe.reindex(tfe.columns,axis=1)
sfv=sfv.reindex(tfv.columns,axis=1)
spp=spp.reindex(tpp.columns,axis=1)
envio=pd.merge(envio,sfa,on='ID_CLIENTE',how='left')
envio=pd.merge(envio,sfc,on='ID_CLIENTE',how='left')
envio=pd.merge(envio,sfd,on='ID_CLIENTE',how='left')
envio=pd.merge(envio,sfe,on='ID_CLIENTE',how='left')
envio=pd.merge(envio,sfv,on='ID_CLIENTE',how='left')
envio=pd.merge(envio,spp,on='ID_CLIENTE',how='left')
envio['TARGET']=model.predict(envio.drop(columns='ID_CLIENTE'),num_iteration=model.best_iteration)
envio = envio.loc[:,['ID_CLIENTE','TARGET']]
envio.to_csv('/home/liiarpi/Downloads/DATA/MOVISTAR/submissions/sub08_DATA3.csv',index=None, sep=',')
envio['ID_CLIENTE']=envio['ID_CLIENTE'].astype(str)
envio['TARGET']=envio['TARGET'].astype('float64')
pd.read_csv('/home/liiarpi/Downloads/DATA/MOVISTAR/submissions/sub08_DATA3.csv').info()<jupyter_output><class 'pandas.core.frame.DataFrame'>
RangeIndex: 70000 entries, 0 to 69999
Data columns (total 2 columns):
ID_CLIENTE    70000 non-null object
TARGET        70000 non-null float64
dtypes: float64(1), object(1)
memory usage: 1.1+ MB<jupyter_text>Probando los resultados en la página oficial obtenemos un 0.67375 en Private Score y obtenemos un 0.66571 en Public Score<jupyter_code>from PIL import Image
Image.open('1.jpg')<jupyter_output><empty_output><jupyter_text>8. USANDO LOS FEATURES HALLADOS EN EL ARCHIVO PROYECTO_FINAL_02<jupyter_code>test=pd.read_csv('Data_tratada_test.csv',na_values=['NaN','nan',-1])

features=['ID_CLIENTE','AIRTIME_IN_TOT_count', 'AIRTIME_OUT_ON_count', 'APP_10_count',
       'APP_1_count', 'APP_2_count', 'APP_4_count', 'APP_5_count',
       'APP_6_count', 'APP_7_count', 'APP_8_count', 'CALLS_IN_TOT_count',
       'CALLS_OUT_ON_count', 'CALLS_OUT_TOT_count', 'CONT_OFF_count',
       'CONT_ON_count', 'CONT_TOT_count', 'DAYS_IN_VOICE_OFF_sum',
       'DAYS_IN_VOICE_TOT_count', 'DAYS_OUT_VOICE_OFF_sum',
       'DEST_VOICE_ON_count', 'DEST_VOICE_count', 'MB_TOTAL_APP_count',
       'N_DIAS_NAVEGACION_count', 'N_DIAS_NAVEGACION_max',
       'N_DIAS_NAVEGACION_sum', 'TOP_CONT_5_count', 'TOP_CONT_5_max',
       'TOP_CONT_5_sum', 'TOP_CONT_OFF_5_count', 'TOP_CONT_OFF_5_max',
       'TOP_CONT_OFF_5_mean', 'TOP_CONT_OFF_5_sum', 'TOP_CONT_ON_5_count',
       'TRAF_DATOS_mean', 'TRAF_DATOS_sum', 'alta_CALLS_IN_OFF_mean',
       'alta_CALLS_OUT_OFF_mean', 'alta_DAYS_IN_VOICE_OFF_mean',
       'alta_DAYS_OUT_VOICE_OFF_mean', 'alta_DEST_VOICE_OFF_mean',
       'alta_TOP_CONT_OFF_5_mean', 'baja_DAYS_IN_VOICE_OFF_mean',
       'baja_DAYS_OUT_VOICE_OFF_mean', 'baja_PANTALLA_mean',
       'baja_TEC_CHIP_mean', 'media_APP_10_mean', 'media_APP_6_mean',
       'media_APP_7_mean', 'media_APP_8_mean', 'media_APP_9_mean',
       'media_N_DIAS_NAVEGACION_mean']
test=test[features]
envio2=pd.read_csv('/home/cristianl/Desktop/MOVISTAR/PAPER2/DATA/TEST/TEST_ENVIO.txt',sep='|')
envio2.head(2)

envio2=pd.merge(envio2,test,on='ID_CLIENTE',how='left')
envio2.head(2)
for n,col in envio2.items():
    if  n != 'ID_CLIENTE': 
        print(n)
        envio2[n][(1-np.isnan(envio2[n]))>0.0001]=0
        a=np.copy(envio2[n])
        envio2[n][np.isnan(a)]=0
        envio2[n][a==np.Inf]=0
        envio2[n][a==-np.Inf]=0
envio2.head()
envio3=pca_modelo.transform(envio2.drop(columns='ID_CLIENTE'))

envio2['TARGET']=modelo.predict(envio3)
envio2 = envio2.loc[:,['ID_CLIENTE','TARGET']]
envio2.to_csv('/home/cristianl/Desktop/MOVISTAR/PAPER3/subm/subfinal.csv',index=None, sep=',')<jupyter_output><empty_output><jupyter_text>Probando los resultados en la página oficial obtenemos un 0.68032 en Private Score y obtenemos un 0.6733 en Public Score a  que nos ubicaría en el segundo puesto<jupyter_code>Image.open('2.jpg')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.1326190476190476, 'fraction_numerical': 0.020761904761904763, 'mean_word_length': 5.254020250148898, 'pattern_counts': {'":': 0, '<': 57, '<?xml version=': 0, '>': 60, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 13, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '513414', 'license': 'MIT', 'n_tokens_mistral': 8421, 'n_tokens_neox': 8144, 'n_words': 1476, 'path': 'Projects-2018-2/Movistar/PROYECTO_IA_01.ipynb', 'repo_name': 'PCL-AI/MT616_2018_2', 'size': '21080'}