#библиотеки

import pandas as pd

from sklearn.metrics import mean_absolute_error

import matplotlib.pyplot as plt

import numpy as np

from sklearn.pipeline import make_pipeline

from sklearn.preprocessing import StandardScaler

from sklearn.ensemble import RandomForestRegressor

from sklearn.tree import DecisionTreeRegressor

from sklearn.model_selection import GridSearchCV

from sklearn.metrics import make_scorer

from sklearn.dummy import DummyRegressor

 

#загружаем данные

data_train = pd.read_csv('/datasets/gold_industry_train.csv')

data_test = pd.read_csv('/datasets/gold_industry_test.csv')

data_full = pd.read_csv('/datasets/gold_industry_full.csv')

 

data_train.info()

data_test.info()

data_full.info()

 

#проверка на наличие дубликатов

data_train.duplicated().sum()

data_test.duplicated().sum()

data_full.duplicated().sum()

 

data_train.isna().mean()

data_test.isna().mean()

 

#Проверьте, что эффективность обогащения рассчитана правильно

concentrate_au = data_train['rougher.output.concentrate_au']

input_feed_au = data_train['rougher.input.feed_au']

output_tail_au = data_train['rougher.output.tail_au']

output_recovery = data_train['rougher.output.recovery']

recovery = (concentrate_au * (input_feed_au - output_tail_au) / input_feed_au

                        / (concentrate_au - output_tail_au) * 100)

print('Эффективность обогащения', recovery)

print('Абсолютная средняя ошибка (MAE) =', mean_absolute_error(output_recovery, recovery))

 

#удаляем пропуски

b_data_train = data_train.dropna()

b_data_train.isna().mean()

 

#Проведите предобработку данных.

data_test.merge(data_train, how='left', indicator=True) \

          .query("_merge == 'left_only'") \

          .drop('_merge', axis=1)[data_test.columns].columns

 

plt.figure(figsize=[10,8])

 

plt.hist(b_data_train['rougher.output.recovery'], bins=90)

plt.xlim([0, 100])

plt.ylim([0, 800])

plt.xlabel("Эффективность обогащения чернового концентрата ")

plt.ylabel("Количество результатов")

 

plt.title("ЭффективностЬ обогащения")

plt.show()

plt.figure(figsize=[10,8])

 

plt.hist(b_data_train['rougher.output.concentrate_au'], bins=100)

plt.xlim([0, 100])

plt.ylim([0, 800])

plt.xlabel("Эффективность обогащения чернового концентрата ")

plt.ylabel("Количество результатов")

 

plt.title("Доля золота в концентрате до очистки")

plt.show()

 

#удаляем нулевые значения не имеющие смылса

b_data_train = b_data_train.drop(b_data_train[b_data_train['rougher.output.recovery'] == 0].index)

b_data_train = b_data_train.drop(b_data_train[b_data_train['final.output.recovery'] == 0].index)

b_data_train.info()

 

#ЗОЛОТО

plt.figure(figsize=[15,10])

 

plt.hist(b_data_train['final.output.concentrate_au'], bins=100, label = 'final', alpha=.5)

plt.hist(b_data_train['primary_cleaner.output.concentrate_au'], bins=100, label = 'primary_cleaner', alpha=.5)

plt.hist(b_data_train['rougher.output.concentrate_au'], bins=100, label = 'rougher.output', alpha=.5)

plt.hist(b_data_train['rougher.input.feed_au'], bins=100, label = 'rougher.input', alpha=.5)

 

plt.xlim([0, 100])

plt.ylim([0, 1200])

 

plt.xlabel("Концентрация золота на выходе этапов")

plt.ylabel("Количество результатов")

 

plt.legend()

 

plt.title("Гистограмма распределения концентрации золота")

plt.show()

#СЕРЕБРО

plt.figure(figsize=[15,10])

 

plt.hist(b_data_train['final.output.concentrate_ag'], bins=110, label = 'final', alpha=.5)

plt.hist(b_data_train['primary_cleaner.output.concentrate_ag'], bins=110, label = 'primary_cleaner', alpha=.5)

plt.hist(b_data_train['rougher.output.concentrate_ag'], bins=110, label = 'rougher.output', alpha=.5)

plt.hist(b_data_train['rougher.input.feed_ag'], bins=100, label = 'rougher.input', alpha=.5)

 

plt.xlim([0, 60])

plt.ylim([0, 1000])

 

plt.xlabel("Концентрация серебра на выходе этапов")

plt.ylabel("Количество результатов")

 

plt.legend()

 

plt.title("Гистограмма распределения концентрации серебра")

plt.show()

 

plt.figure(figsize=[15,10])

 

plt.hist(b_data_train['final.output.concentrate_pb'], bins=100, label = 'final', alpha=.5)

plt.hist(b_data_train['primary_cleaner.output.concentrate_pb'], bins=100, label = 'primary_cleaner', alpha=.5)

plt.hist(b_data_train['rougher.output.concentrate_pb'], bins=100, label = 'rougher.output', alpha=.5)

plt.hist(b_data_train['rougher.input.feed_pb'], bins=100, label = 'rougher.input', alpha=.5)

 

 

plt.xlim([0, 60])

plt.ylim([0, 1000])

 

plt.xlabel("Концентрация свинца на выходе этапов")

plt.ylabel("Количество результатов")

 

plt.legend()

 

plt.title("Гистограмма распределения концентрации свинца")

plt.show()

 

 

plt.figure(figsize=[15,10])

 

plt.hist(b_data_train['rougher.input.feed_size'], bins=220, label = 'Размер-обучающая', alpha=.55)

plt.hist(data_test['rougher.input.feed_size'], bins=220, label = 'Размер-тестовая', alpha=.55)

 

plt.xlim([0, 60])

plt.ylim([0, 1200])

 

plt.xlabel("Размер сырья")

plt.ylabel("Количество результатов")

 

plt.legend()

 

plt.title("Гистограмма распределения гранул сырья перед флотацией")

plt.show()

 

# Перед первичной

plt.figure(figsize=[15,10])

 

plt.hist(b_data_train['primary_cleaner.input.feed_size'], bins=100, label = 'Размер-обучающая', alpha=.5,density=True)

plt.hist(data_test['primary_cleaner.input.feed_size'], bins=100, label = 'Размер-тестовая', alpha=.5,density=True)

 

plt.xlim([0, 20])

plt.ylim([0, 800])

 

plt.xlabel("Размер гранул")

plt.ylabel("Количество результатов")

 

plt.legend()

 

plt.title("Гистограмма распределения гранул сырья перед первичной очисткой")

plt.show()

 

#постоим гистограмму со всеми этапами

final_output_concentrate_all = (b_data_train['final.output.concentrate_au'] +

                                      b_data_train['final.output.concentrate_ag'] +

                                      b_data_train['final.output.concentrate_pb'])

 

primary_cleaner_output_concentrate_all = (b_data_train['primary_cleaner.output.concentrate_au'] +

                                                b_data_train['primary_cleaner.output.concentrate_ag'] +

                                                b_data_train['primary_cleaner.output.concentrate_pb'])

 

rougher_output_concentrate_all = (b_data_train['rougher.output.concentrate_au'] +

                                        b_data_train['rougher.output.concentrate_ag'] +

                                        b_data_train['rougher.output.concentrate_pb'])

rougher_input_all = (b_data_train['rougher.input.feed_au'] +

                                        b_data_train['rougher.input.feed_ag'] +

                                        b_data_train['rougher.input.feed_pb'])

 

 

plt.figure(figsize=[15,10])

 

plt.hist(final_output_concentrate_all, bins=100, label = 'final_output', alpha=.4)

plt.hist(primary_cleaner_output_concentrate_all, bins=100, label = 'primary_cleaner_output', alpha=.4)

plt.hist(rougher_output_concentrate_all, bins=100, label = 'rougher_output', alpha=.4)

plt.hist(rougher_input_all, bins=100, label = 'rougher_input', alpha=.4)

 

plt.xlim([0, 100])

plt.ylim([0, 1200])

 

plt.xlabel("Концентраця")

plt.ylabel("Количество результатов")

 

plt.legend()

 

plt.title("Гистограмма распределения концентраций на всех этапах")

plt.show()

 

b_data_train[b_data_train['primary_cleaner.output.concentrate_au'] < 1]['primary_cleaner.output.concentrate_au'].count()

b_data_train = b_data_train.drop(b_data_train[b_data_train['primary_cleaner.output.concentrate_au'] == 0].index)

 

def SMAPE(y_true,y_pred):

    res = np.mean(abs(y_true - y_pred)/((abs(y_true)+abs(y_pred))/2))*100

    return res

def final_SMAPE(SMAPE_rougher,SMAPE_final):

    return (0.25*SMAPE_rougher + 0.75*SMAPE_final)

 

features_columns = data_test.columns[1:] # Оставим все столбцы кроме data, так как не несет никаког осмысла для обучения

rougher_features_columns = set(features_columns[12:34]) # Для предсказания rougher.output.recovery используем данные

#из стобцов rougher

final_features_columns = set(features_columns) # Тут будем использовать все столбцы из тестовой выборки

 

# Подготовка признаков для final.output.recovery

columns_to_delete = set(b_data_train.columns) - final_features_columns

train_features_data_final = b_data_train.drop(columns_to_delete, axis=1)

 

# Подготовка признаков для rougher.output.recovery

columns_to_delete = set(train_features_data_final.columns) - rougher_features_columns

train_features_data_rougher = train_features_data_final.drop(columns_to_delete, axis=1)

train_target_data_final = b_data_train['final.output.recovery']

train_target_data_rougher = b_data_train['rougher.output.recovery']

test_features = data_test.drop('date', axis=1)

test_features_final = test_features

columns_to_delete = set(test_features_final.columns) - rougher_features_columns

test_features_rougher = test_features_final.drop(columns_to_delete, axis=1)

 

train_features_data_rougher.info()

 

# Cчетчик функции - Создайте показатель оценки на основе показателя производительности или функции потерь.

custom_score = make_scorer(SMAPE,greater_is_better=False)

#Постройте Pipeline из заданных оценок.

model_forest = make_pipeline(StandardScaler(),RandomForestRegressor())

model_tree = make_pipeline(StandardScaler(),DecisionTreeRegressor())

 

#инициализация

params_RF = {"randomforestregressor__n_estimators":[5,50],

             "randomforestregressor__max_depth":[1,11]}

params_DT= {"decisiontreeregressor__max_depth":[1,6]}

#Исчерпывающий поиск по указанным значениям параметров для оценщика.

grid_rougher = GridSearchCV(model_forest,param_grid = params_RF,scoring=custom_score)

grid_final = GridSearchCV(model_forest,param_grid = params_RF,scoring=custom_score)

grid_rougher_DT = GridSearchCV(model_tree,param_grid = params_DT,scoring=custom_score)

grid_final_DT = GridSearchCV(model_tree,param_grid = params_DT,scoring=custom_score)

 

#обучение

grid_rougher.fit(train_features_data_rougher,train_target_data_rougher)

grid_final.fit(train_features_data_final,train_target_data_final)

grid_rougher_DT.fit(train_features_data_rougher,train_target_data_rougher)

grid_final_DT.fit(train_features_data_final,train_target_data_final)

 

print("Лучшие модели")

print(grid_rougher.best_estimator_)

print(grid_final.best_estimator_)

print(grid_rougher_DT.best_estimator_)

print(grid_final_DT.best_estimator_)

 

best_score_rougher = grid_rougher.best_score_

best_score_final = grid_final.best_score_

best_score_rougher_DT = grid_rougher_DT.best_score_

best_score_final_DT = grid_final_DT.best_score_

 

print("rougher")

print("RandomForest",best_score_rougher,"DecisionTree",best_score_rougher_DT)

print("final")

print("RandomForest",best_score_final,"DecisionTree",best_score_final_DT)

 

#тестовая выборка

test_frame_for_target = data_test.merge(data_full.loc[:,['date',"rougher.output.recovery",

                                                           "final.output.recovery"]],on = 'date')

target_test_rougher = test_frame_for_target["rougher.output.recovery"]

target_test_final = test_frame_for_target["final.output.recovery"]

not_nan_index = set(test_features_rougher.index)

rougher_recovery_real = data_full.loc[not_nan_index,'rougher.output.recovery']

final_recovery_real = data_full.loc[test_features_final.index,'final.output.recovery']

 

final_recovery_real = data_full.loc[not_nan_index,'final.output.recovery']

test_features_rougher = test_features_rougher.loc[not_nan_index,:]

test_features_final = test_features_final.loc[not_nan_index,:]

 

rogher_test = grid_rougher.predict(test_features_rougher)

final_test = grid_final.predict(test_features_final)