使用深度学习预测员工流失率

    def __init__(self, name):

        self.name = name # candidato o empleado

        self.scalers = {} # asignar cada scaler con el nombre de la columna (ej.'Age')

    def add_scaler(self, scaler, name):

        self.scalers[name] = scaler

# Initialize a standard_scaler class to hold all scalers for future reverse scaling

scalers_empleados = standard_scaler('empleados')

def scale_and_generate_scaler(data):

    standard_scaler = StandardScaler()

    scaled = standard_scaler.fit_transform(data.astype('int64').values.reshape(-1, 1))

    return scaled, standard_scaler

def scale_array(scaler, array):

    return scaler.transform([array])

def inverse_scale_array(scaler, array):

    return scaler.inverse_transform([array])

def scale_append(data, scalers, name):

    scaled, scaler = scale_and_generate_scaler(data[name])

    scalers.add_scaler(scaler, name)

    return scaled, scalers

# Select features to scale

var_empleados_num = [

 'Age',

 'BusinessTravel_Num',

 'DistanceFromHome',

 'EnvironmentSatisfaction',

 'JobInvolvement',

 'JobSatisfaction',

 'MonthlyIncome',

 'OverTime_Num',

 'YearsAtCompany',

 'WorkLifeBalance',

 'Education',

 'MaritalStatus_Num',

 'NumCompaniesWorked',

 'RelationshipSatisfaction',

 'TotalWorkingYears'

]

# Scale each feature, save each feature's scaler

for var in var_empleados_num:

    data_empleados_upsampled[var], scalers_empleados = scale_append(data_empleados_upsampled, scalers_empleados, var)

X_train, X_test = train_test_split(data_empleados_upsampled, test_size=0.2, random_state=RANDOM_SEED)

X_train = data_empleados_upsampled

y_train = X_train['Attrition_Num']

X_train = X_train.drop(['Attrition_Num', 'Attrition', 'BusinessTravel', 'OverTime', 'MaritalStatus', 'YearsAtCompany'], axis=1)

y_test = X_test['Attrition_Num']

X_test = X_test.drop(['Attrition_Num', 'Attrition', 'BusinessTravel', 'OverTime', 'MaritalStatus','YearsAtCompany'], axis=1)

X_train = X_train.values

X_test = X_test.values

# One-Hot encoding

y_train_hot, label_encoder = one_hot_values(y_train)

y_test_hot, label_encoder_test = one_hot_values(y_test)

def evaluate_model(model, X_train):

    preds = model.predict(X_train)

    y_train_inv = [inverse_one_hot(label_encoder_train,np.array([list(y_train_hot[i])])) for i in range(len(y_train_hot))]

    #y_train_inv = np.round(scalers_empleados_yac.scalers['YearsAtCompany'].inverse_transform([y_train_inv]))

    y_train_inv = np.array(y_train_inv).flatten()

    preds_inv = [inverse_one_hot(label_encoder_train,np.array([list(preds[i])])) for i in range(len(preds))]

    #preds_inv = scalers_empleados_yac.scalers['YearsAtCompany'].inverse_transform([preds_inv])

    preds_inv = np.array(preds_inv).flatten()

    correct = 0

    over = 0

    under = 0

    errors = []

    for i in range(len(preds_inv)):

        if preds_inv[i] == y_train_inv[i]:

            correct += 1

        elif (preds_inv[i]) < (y_train_inv[i]):

            under += 1

        elif (preds_inv[i]) > (y_train_inv[i]):

            over += 1

        errors.append(((preds_inv[i]) - (y_train_inv[i])))

    print("correct: {}, over {}, under {}, accuracy {}, mse {}".format(correct, over, under, round(correct/len(preds_inv),3), np.round(np.array(np.power(errors,2)).mean(),3)))

    print("errors:",pd.Series(np.array([abs(i) for i in errors if i != 0])).describe())

    print("preds",pd.Series(preds_inv).describe())

    print("y_train",pd.Series(y_train_inv).describe())

    print(pd.Series(preds_inv).value_counts())

    print(pd.Series(y_train_inv).value_counts())

    print(sns.boxplot(np.array([abs(i) for i in errors if i != 0])))

    return y_train_inv, preds_inv