Azure ์ฒดํ ๊ณ์ ๊ฐ์ ํจ : 12๊ฐ์ ์ธ๊ธฐ๋ฌด๋ฃ + 30์ผ ํฌ๋ ๋ง \224,930
12๊ฐ์ ๋ฌด๋ฃ ์ ํ
ํญ์ ๋ฌด๋ฃ? ์ ํ
Azure Machine Learning ์๋น์ค ์ค๋ช ์
https://docs.microsoft.com/ko-kr/azure/machine-learning/service/
Azure Machine Learning ์๋น์ค ์ค๋ช ์ - ์์ต์, API ์ฐธ์กฐ
Azure Machine Learning Service๋ ์ ์ํ๊ฒ ๋ฐ์ดํฐ๋ฅผ ์ค๋นํ๊ณ , ๊ธฐ๊ณ ํ์ต ๋ชจ๋ธ์ ํ์ต ๋ฐ ๋ฐฐํฌํ ์ ์๋ SDK ๋ฐ ์๋น์ค๋ฅผ ์ ๊ณตํฉ๋๋ค. ์๋ ํฌ๊ธฐ ์กฐ์ ์ปดํจํ ๋ฐ ํ์ดํ๋ผ์ธ์ ์ฌ์ฉํ์ฌ ์์ฐ์ฑ์ ๊ฐ์ ํ๊ณ ๋น์ฉ์ ์ค์ด์ธ์. PyTorch, TensorFlow ๋ฐ scikit-learn๊ณผ ๊ฐ์ ์คํ ์์ค Python ํ๋ ์์ํฌ์ ํจ๊ป ์ด๋ฌํ ๊ธฐ๋ฅ์ ์ฌ์ฉํ์ธ์. ๋น ๋ฅธ ์์ ๋ฐ ์์ต์๋ฅผ ์์ํด ๋ณด์ธ์.
docs.microsoft.com
Azure Machine Learning Service
- ์ ์ํ๊ฒ ๋ฐ์ดํฐ ์ค๋น, ๊ธฐ๊ณ ํ์ต ๋ชจ๋ธ์ ํ์ต ๋ฐ ๋ฐฐํฌํ ์ ์๋ SDK ๋ฐ ์๋น์ค๋ฅผ ์ ๊ณต
- ์๋ ํฌ๊ธฐ ์กฐ์ ์ปดํจํ ๋ฐ ํ์ดํ๋ผ์ธ์ ์ฌ์ฉํ์ฌ ์์ฐ์ฑ์ ๊ฐ์
- PyTorch, TensorFlow ๋ฐ scikit-learn๊ณผ ๊ฐ์ ์คํ ์์ค Python ํ๋ ์์ํฌ์ ํจ๊ป ์ด๋ฌํ ๊ธฐ๋ฅ ์ฌ์ฉ ๊ฐ๋ฅ
Microsoft Azure์ ๋ก๊ทธ์ธ
๋ก๊ทธ์ธ Microsoft Azure(์ผ)๋ก ๊ณ์ ๊ณ์ ์ด ์์ผ์ญ๋๊น? ์๋ก ๋ง๋์ธ์! ๋ณธ์ธ ๊ณ์ ์ผ๋ก ๋ก๊ทธ์ธํ ์ ์์ต๋๊น? ©2019 Microsoft ์ฌ์ฉ ์ฝ๊ด ๊ฐ์ธ์ ๋ณด์ฒ๋ฆฌ๋ฐฉ์นจ
portal.azure.com
* Azure Portal์ ๋ก๊ทธ์ธ ํ [+ ๋ฆฌ์์ค ๋ง๋ค๊ธฐ] -> Machine Learning service workspace (Machine Learning ์๋น์ค ์์ ์์ญ) -> ๋ง๋ค๊ธฐ
ํ๋ |
์ค๋ช |
์์ ์์ญ ์ด๋ฆ |
์์ ์์ญ์ ์๋ณํ๋ ๊ณ ์ ํ ์ด๋ฆ์ ์ ๋ ฅํฉ๋๋ค. ์ด ์์ ์์๋ docs-ws๋ฅผ ์ฌ์ฉํฉ๋๋ค. ์ด๋ฆ์ ๋ฆฌ์์ค ๊ทธ๋ฃน ์ ์ฒด์์ ๊ณ ์ ํด์ผ ํฉ๋๋ค. ๋ค๋ฅธ ์ฌ์ฉ์๊ฐ ๋ง๋ ์์ ์์ญ๊ณผ ๊ตฌ๋ณ๋๊ณ ๊ธฐ์ตํ๊ธฐ ์ฌ์ด ์ด๋ฆ์ ์ฌ์ฉํ์ธ์. |
๊ตฌ๋ |
์ฌ์ฉํ Azure ๊ตฌ๋ ์ ์ ํํฉ๋๋ค. |
๋ฆฌ์์ค ๊ทธ๋ฃน |
๊ตฌ๋ ์์ ๊ธฐ์กด ๋ฆฌ์์ค ๊ทธ๋ฃน์ ์ฌ์ฉํ๊ฑฐ๋ ์ด๋ฆ์ ์ ๋ ฅํ์ฌ ์ ๋ฆฌ์์ค ๊ทธ๋ฃน์ ๋ง๋ญ๋๋ค. ๋ฆฌ์์ค ๊ทธ๋ฃน์ Azure ์๋ฃจ์ ์ ๊ด๋ จ๋ ๋ฆฌ์์ค๋ฅผ ๋ณด์ ํ๋ ์ปจํ ์ด๋์ ๋๋ค. ์ด ์์์๋ docs-aml์ ์ฌ์ฉํฉ๋๋ค. |
Location |
์ฌ์ฉ์ ๋ฐ ๋ฐ์ดํฐ ๋ฆฌ์์ค์ ๊ฐ์ฅ ๊ฐ๊น์ด ์์น๋ฅผ ์ ํํฉ๋๋ค. ์์ ์์ญ์ด ๋ง๋ค์ด์ง๋ ์์น์ ๋๋ค. |
* ๋ง๋ค๊ธฐ - ์์ ์์ญ ๋ง๋๋ ๋ฐ ๋ช ๋ถ ์ ๋ ์์๋จ
* ๋ฐฐํฌ์ํ ํ์ธ : ๋๊ตฌ ๋ชจ์์์ ์๋ฆผ ์์ด์ฝ(์ข ๋ชจ์)์ ์ ํ
Azure Notebook์์ ์์ - ๋๋ฌ์ ๋ ธํธ๋ถ ์คํํ๊ณ ํํ ๋ฆฌ์ผ์ ์ค์ต. Python 3.6 ์ฌ์ฉ.
https://docs.microsoft.com/ko-kr/azure/machine-learning/service/tutorial-data-prep
ํ๊ท ๋ชจ๋ธ ์์ต์: ๋ฐ์ดํฐ ์ค๋น - Azure Machine Learning service
์ด ์์ต์์ 1๋ถ์์๋ Azure Machine Learning SDK๋ฅผ ์ฌ์ฉํ์ฌ ํ๊ท ๋ชจ๋ธ๋ง์ ์ํด Python์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ค๋นํ๋ ๋ฐฉ๋ฒ์ ๋ฐฐ์๋๋ค.
docs.microsoft.com
ํ์ ์ดํ ๋น์ฉ ์์ธก - ๋ ์ง ๋ฐ ์๊ฐ, ์น๊ฐ ์ ์์น ์ ํ์ด ํฌํจ๋จ
A. Regression modeling์ ์ํ ๋ฐ์ดํฐ ์ค๋น
1. ๋ฐ์ดํฐ ๋ก๋
- auto_read_file() method๋ ์ ๋ ฅ ํ์ผ ํ์์ ์๋์ผ๋ก ์ธ์ํจ
- Dataflow ๊ฐ์ฒด๋ ๋ฐ์ดํฐ ํ๋ ์ํ๊ณ ๋น์ทํ๊ณ ,
represents a series of lazily-evaluated, immutable operations on data.
Operations can be added by invoking the different transformation and filtering methods available.
The result of adding an operation to a Dataflow is always a new Dataflow object.
2. ๋ฐ์ดํฐ ์ ๋ฆฌ(ํ์ ๋ฐ ํํฐ ๋ณํ, ์ด ๋ถํ ๋ฐ ์ด๋ฆ ๋ฐ๊พธ๊ธฐ)
- ์ ์ฒด Null ๋ฐ์ดํฐ ์ ๊ฑฐ(๊ธฐ๊ณ ํ์ต ๋ชจ๋ธ์ ์ ํ๋๋ฅผ ๋์ด๋ ๋ฐ ๋์์ด ๋จ)
- ์ ํจํ ์ด ์ ํ๊ณ ์ด ์ด๋ฆ ๋ณ๊ฒฝ
- ํ์ ๋ณ๊ฒฝ : ์๊ฒฝ๋ 10์ง ํ์์ผ๋ก ๋ณ๊ฒฝ, distance ์ซ์ ํ์์ผ๋ก ๋ณํ
- ๋ด์์๊ฐ ์๋ ์ขํ & ๋๋ฝ๋ ์ขํ (๋์ ๋ฐ) ํํฐ๋ง ํจ (์ฃผ๊ด์ ๋ถ์) : ์ต์, ์ต๋ ๊ฒฝ๊ณ ์ ์๋ก ํํฐ๋งํจ.
- store_forward ๊ฐ ๋๋ฝ๋ ๋ถ๋ถ์ "N"์ผ๋ก ๋ฐ๊พผ๋ค.
- ๋ ์ง/์๊ฐ ๊ฐ์ ๊ฐ๊ฐ ๋ ์ง ๋ฐ ์๊ฐ ์ด๋ก ๋ถํ
3. ๋ฐ์ดํฐ ๋ณํ ( ์๋ ๋ ์ง ํ์ : 2013-08-01 08:14:37 )
- ์น์ฐจ&ํ์ฐจ ๋ ์ง๋ฅผ ์์ผ, ์๊ฐ ์ผ์, ์ ๊ฐ์ผ๋ก ์ถ๊ฐ ๋ถํ ํจ. ์๋ ๋ ์ง๋ ์ญ์ (pickup_datetime, dropoff_datetime)
(์๊ฐ, ๋ถ ๋ฐ ์ด ๊ฐ์ ์ธ๋ฐํ ์๊ฐ ๊ธฐ๋ฅ์ ๋ชจ๋ธ ํ์ต์ ์ ์ฉ)
(์๋ก์ด ์๊ฐ ๊ธฐ๋ฐ ๊ธฐ๋ฅ์ ๋ง๋ค๋ฉด ๊ธฐ๊ณ ํ์ต ๋ชจ๋ธ ์ ํ๋๊ฐ ํฅ์๋จ. ์๋ฅผ ๋ค์ด ํ์ผ์ ๋ํ ์ ๊ธฐ๋ฅ์ ์์ฑํ๋ฉด ํ์ผ๊ณผ ํ์ ์๊ธ ๊ฐ์ ๊ด๊ณ๋ฅผ ์ค์ ํ๋ ๋ฐ ๋์์ด ๋๋ฉฐ, ํน์ ์์ผ์๋ ์์๊ฐ ๋ง์ ์๊ธ์ด ๋ ๋น์ผ ๊ฒฝ์ฐ๊ฐ ์์ฃผ ์๋ค.)
- ์ต์ข ํํฐ : distance > 0, cost > 0
โ ์ด ๋จ๊ณ๋ฅผ ์ํํ๋ฉด ๊ธฐ๊ณ ํ์ต ๋ชจ๋ธ ์ ํ๋๊ฐ ๋ํญ ํฅ์๋จ
โ ๋น์ฉ ๋๋ ๊ฑฐ๋ฆฌ๊ฐ 0์ธ ๋ฐ์ดํฐ ์์๋ ์์ธก ์ ํ๋๋ฅผ ๋จ์ดํธ๋ฆฌ๋ ์ค๋ํ ์ด์๊ฐ์ ๋ํ๋ด๊ธฐ ๋๋ฌธ
- ๋จธ์ ๋ฌ๋ ๋ชจ๋ธ์ ์ฌ์ฉํ ์ ์๋๋ก ์์ ํ ๋ณํ & ์ค๋น๋ dataflow ๊ฐ์ฒด๊ฐ ์๊ฒผ๋ค : dflows.dprep์ผ๋ก ์ ์ฅ
import os file_path = os.path.join(os.getcwd(), "dflows.dprep") final_df.save(file_path)
B. ML ๋ชจ๋ธ ์๋ ํ์ต
1. ๋ฐ์ดํฐ ํ์ (ํ์ต ๋ฐ ํ ์คํธ ์ธํธ๋ก ๋ฐ์ดํฐ ๋ถํ ; Split the data into train and test sets)
- ์ด์ ์ ๋ง๋ dataflow ๊ฐ์ฒด dflows.dprep ํ์ผ์ ์ด์ด์ ๊ฒฐ๊ณผ๋ฅผ ๊ฒํ ํจ
import azureml.dataprep as dprep file_path = os.path.join(os.getcwd(), "dflows.dprep") dflow_prepared = dprep.Dataflow.open(file_path) dflow_prepared.get_profile()
- dflow_x : ์คํ์ฉ ๋ฐ์ดํฐ
- dflow_y : ์์ธก๊ฐ - ๋น์ฉ
dflow_X = dflow_prepared.keep_columns(['pickup_weekday','pickup_hour', 'distance','passengers', 'vendor']) dflow_y = dflow_prepared.keep_columns('cost')
- sklearn ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ train_test_split ํจ์ ์ฌ์ฉํด์ ๋ฐ์ดํฐ๋ฅผ ํ์ต, ํ ์คํธ ์ธํธ๋ก ๋ถํ ํ๋ค. ์ด ํจ์๋ ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ธ ํ์ต์ฉ x(๊ธฐ๋ฅ) ๋ฐ์ดํฐ ์ธํธ ๋ฐ ํ ์คํธ์ฉ y(์์ธก ๊ฐ) ๋ฐ์ดํฐ ์ธํธ๋ก ๋ถ๋ฆฌํ๋ค. test_size ๋งค๊ฐ๋ณ์๋ ํ ์คํธ์ ํ ๋นํ ๋ฐ์ดํฐ ๋ฐฑ๋ถ์จ์ ์ ์. random_state ๋งค๊ฐ๋ณ์๋ ํ์ต-ํ ์คํธ ๋ถํ ์ด ํญ์ ๊ฒฐ์ ์ ์ด ๋๋๋ก ์์ ์์ฑ๊ธฐ์ ์๋๋ฅผ ์ค์ ํ๋ค.
from sklearn.model_selection import train_test_split x_df = dflow_X.to_pandas_dataframe() y_df = dflow_y.to_pandas_dataframe() x_train, x_test, y_train, y_test = train_test_split(x_df, y_df, test_size=0.2, random_state=223) # flatten y_train to 1d array y_train.values.flatten()
- ์ด ๋จ๊ณ์ ๋ชฉ์ : ๋ฐ์ดํฐ ์์์์ ์ค์ ์ ํ๋๋ฅผ ์ธก์ ํ๊ธฐ ์ํด ๋ชจ๋ธ ํ์ต์ ์ฌ์ฉ๋์ง ์์ ์๋ฃ๋ ๋ชจ๋ธ์ ํ ์คํธํ๋ ๊ฒ์ด๋ค.
- ์ฆ, ์ ํ์ต๋ ๋ชจ๋ธ์ ์์ง ํ์ธ๋์ง ์์ ๋ฐ์ดํฐ์์ ์ ํํ ์์ธก์ ์ํํ ์ ์์ด์ผ ํ๋ค.
- ์ด์ ๋ชจ๋ธ์ ์ํ ์๋ ํ์ต์ ํ์ํ ํจํค์ง ๋ฐ ๋ฐ์ดํฐ๊ฐ ์ค๋น๋์๋ค.
The purpose of this step is to have data points to test the finished model that haven't been used to train the model, in order to measure true accuracy. In other words, a well-trained model should be able to accurately make predictions from data it hasn't already seen. You now have the necessary packages and data ready for autotraining your model.
2. ์๋์ผ๋ก ๋ชจ๋ธ ํ์ต (Automatically train a model)
1. Define settings for the experiment run. Attach your training data to the configuration, and modify settings that control the training process.
(experiment ์คํ์ ์ํ ์ค์ ์ ์ ์ํ๊ณ training ๋ฐ์ดํฐ๋ฅผ configuration์ ์ฐ๊ฒฐ, training process๋ฅผ ์ ์ดํ๋ settings๋ฅผ ์์ ํ๋ค. )
2. Submit the experiment for model tuning. After submitting the experiment, the process iterates through different machine learning algorithms and hyperparameter settings, adhering to your defined constraints. It chooses the best-fit model by optimizing an accuracy metric.
(๋ชจ๋ธ ํ๋์ ์ํ ์คํ์ ์ ์ถ ํ ํ, process๋ ๋๊ฐ ์ ์ํ constraints๋ฅผ ์ค์ํ๋ different ๊ธฐ๊ณํ์ต ์๊ณ ๋ฆฌ์ฆ & hyperparameter settings์ ๋ฐ๋ณตํ๋ค. ์ ํ๋ ๋ฉํธ๋ฆญ์ ์ต์ ํํ์ฌ ๊ฐ์ฅ ์ ํฉํ ๋ชจ๋ธ์ ์ ํํ๋ค.)
์๋ ์์ฑ ๋ฐ ํ๋์ ์ํ ์ค์ ์ ์ (Define settings for autogeneration and tuning)
Define the experiment parameter and model settings for autogeneration and tuning.
์๋์์ฑ๊ณผ ํ๋์ ์ํ ์คํ ๋งค๊ฐ๋ณ์ํ๊ณ ๋ชจ๋ธ์ ๋ํ ์ค์ ์ ์ ์ํ๋ค.
View the full list of settings.
Submitting the experiment with these default settings will take approximately 10-15 min,
๊ธฐ๋ณธ ์ค์ ์ ์ฌ์ฉํด์ ์คํ์ ์ ์ถํ๋๋ฐ, ์ฝ 10~15๋ถ
but if you want a shorter run time, reduce either iterations or iteration_timeout_minutes.
iterations / iteration_timeout_minutes ์ค ํ๋๋ฅผ ์ค์ด๋ฉด ์คํ ์๊ฐ์ ์ค์ผ ์ ์๋ค.
automl_settings = { "iteration_timeout_minutes" : 10, "iterations" : 30, "primary_metric" : 'spearman_correlation', "preprocess" : True, "verbosity" : logging.INFO, "n_cross_validations": 5 }
AutoMLConfig์ ๋ํ ๋งค๊ฐ๋ณ์๋ก ์ ์๋ ํ์ต ์ค์ ์ ์ฌ์ฉํ๋ค. (automl_settings)
๋ํ ํ์ต ๋ฐ์ดํฐ ๋ฐ ๋ชจ๋ธ์ ์ ํ์ ์ง์ ํฉ๋๋ค. (์ฐ๋ฆฌ๋ regression)
from azureml.train.automl import AutoMLConfig # local compute automated_ml_config = AutoMLConfig(task = 'regression', debug_log = 'automated_ml_errors.log', path = project_folder, X = x_train.values, y = y_train.values.flatten(), **automl_settings)
์๋ ํ๊ท ๋ชจ๋ธ ํ์ต
์คํ์ ์์ํ์ฌ ๋ก์ปฌ๋ก ์คํํฉ๋๋ค. ์ ์๋ automated_ml_config ๊ฐ์ฒด๋ฅผ ์คํ์ ์ ๋ฌํฉ๋๋ค. ์คํํ๋ ๋์ ์งํ๋ฅ ์ ํ์ธํ๋ ค๋ฉด ์ถ๋ ฅ์ True๋ก ์ค์ ํฉ๋๋ค.
from azureml.core.experiment import Experiment experiment=Experiment(ws, experiment_name) local_run = experiment.submit(automated_ml_config, show_output=True)
ํ์๋๋ ์ถ๋ ฅ์ ์คํ์ด ์คํ๋จ์ ๋ฐ๋ผ ์ค์๊ฐ์ผ๋ก ์ ๋ฐ์ดํธ๋๋ค.
๊ฐ ๋ฐ๋ณต์ ๊ฒฝ์ฐ ๋ชจ๋ธ ์ ํ, ์คํ ์ง์ ๋ฐ ํ์ต ์ ํ๋๊ฐ ํ์๋จ
PIPELINE, DURATION, METRIC, BEST
ํ๋ BEST๋ ๋ฉํธ๋ฆญ ์ ํ์ ๋ฐ๋ผ ์ต์ ์ ์คํ ํ์ต ์ ์๋ฅผ ์ถ์ ํ๋ค.
3. ๊ฒฐ๊ณผ ํ์
Jupyter ์์ ฏ์ ์ฌ์ฉํ๊ฑฐ๋ ์คํ ๊ธฐ๋ก์ ๊ฒ์ฌํ์ฌ ์๋ ํ์ต ๊ฒฐ๊ณผ๋ฅผ ์ดํด๋ด ๋๋ค.
์ต์ 1: ๊ฒฐ๊ณผ๋ฅผ ๋ณด์ฌ ์ฃผ๋ Jupyter ์์ ฏ ์ถ๊ฐ
Jupyter Notebook์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ ์ด Jupyter Notebook ์์ ฏ์ ์ฌ์ฉํ์ฌ ๋ชจ๋ ๊ฒฐ๊ณผ์ ๋ํ ๊ทธ๋ํ ๋ฐ ํ ์ด๋ธ์ ํ์ธ
from azureml.widgets import RunDetails RunDetails(local_run).show()
์ต์ 2: Python์์ ๋ชจ๋ ์คํ ๋ฐ๋ณต ๊ฐ์ ธ์ค๊ธฐ ๋ฐ ๊ฒ์ฌ (Option 2: Get and examine all run iterations in Python)
๋๋ ๊ฐ ์คํ์ ๊ธฐ๋ก์ ๊ฒ์ํ๊ณ ๊ฐ ๋ฐ๋ณต ์คํ์ ๋ํ ๊ฐ๋ณ ๋ฉํธ๋ฆญ์ ์ดํด๋ณผ ์ ์์ต๋๋ค. ๊ฐ ๊ฐ๋ณ ๋ชจ๋ธ ์คํ์ ๋ํด RMSE(root_mean_squared_error)๋ฅผ ๊ฒ์ฌํ์ฌ ๋๋ถ๋ถ์ ๋ฐ๋ณต์ด ์ ์ ํ ์ฌ๋ฐฑ($3~4) ๋ด์์ ํ์ ์๊ธ์ ์์ธกํ๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
children = list(local_run.get_children()) metricslist = {} for run in children: properties = run.get_properties() metrics = {k: v for k, v in run.get_metrics().items() if isinstance(v, float)} metricslist[int(properties['iteration'])] = metrics rundata = pd.DataFrame(metricslist).sort_index(1) rundata
4. ์ต์ ๋ชจ๋ธ ๊ฒ์
๋ฐ๋ณต ์ค์์ ์ต์ ์ ํ์ดํ๋ผ์ธ์ ์ ํํ๋ค.
automl_classifier์ ๋ํ get_output ๋ฉ์๋๋ ๋ง์ง๋ง ๋ง์ถค ํธ์ถ์ ๋ํ ์ต์ ์ ์คํ ๋ฐ ๋ง์ถค ๋ชจ๋ธ์ ๋ฐํํ๋ค.
get_output์ ๋ํ ์ค๋ฒ๋ก๋๋ฅผ ์ฌ์ฉํ์ฌ ๋ชจ๋ ๊ธฐ๋ก๋ ๋ฉํธ๋ฆญ ๋๋ ํน์ ๋ฐ๋ณต์ ๋ํ ์ต์ ์ ์คํ ๋ฐ ๋ง์ถค ๋ชจ๋ธ ๊ฒ์ ๊ฐ๋ฅ
best_run, fitted_model = local_run.get_output() print(best_run) print(fitted_model)
5. ์ต์ ๋ชจ๋ธ ์ ํ๋ ํ ์คํธ
์ต์ ๋ชจ๋ธ์ ์ฌ์ฉํ์ฌ ํ ์คํธ ๋ฐ์ดํฐ ์ธํธ์์ ์์ธก์ ์คํํ์ฌ ํ์ ์๊ธ์ ์์ธกํ๋ค.
predict ํจ์๋ ์ต์ ๋ชจ๋ธ์ ์ฌ์ฉํ๊ณ x_test ๋ฐ์ดํฐ ์ธํธ์์ y(trip ๋น์ฉ) ๊ฐ์ ์์ธกํ๋ค.
y_predict์์ ์ฒซ 10๊ฐ์ ์์ธก ๋น์ฉ ๊ฐ์ ์ถ๋ ฅ
y_predict = fitted_model.predict(x_test.values) print(y_predict[:10])
์ค์ ๋น์ฉ ๊ฐ๊ณผ ๋น๊ตํ์ฌ ์์ธก ๋น์ฉ ๊ฐ์ ์๊ฐํํ๋ ์ฐ์ ๋(a scatter)๋ฅผ ๋ง๋ ๋ค.
๋ค์ ์ฝ๋์์๋ distance ๊ธฐ๋ฅ(feature)์ x-์ถ์ผ๋ก, trip cost๋ฅผ y-์ถ์ผ๋ก ์ฌ์ฉํ๋ค.
๊ฐ trip ๊ฑฐ๋ฆฌ ๊ฐ์์ ์์ธก ๋น์ฉ์ ์ฐจ์ด๋ฅผ ๋น๊ตํ๊ธฐ ์ํด ์ฒ์ 100๊ฐ์ ์์ธก ๋ฐ ์ค์ ๋น์ฉ ๊ฐ์ด separate series๋ก ๋ง๋ค์ด์ง๋๋ค.
๋ํ๋ฅผ ์ดํด๋ณด๋ฉด ๊ฑฐ๋ฆฌ/๋น์ฉ ๊ด๊ณ๊ฐ ๊ฑฐ์ ์ ํ์ด๊ณ , ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์์ธก ๋น์ฉ ๊ฐ์ด ๋์ผํ ์ฌํ ๊ฑฐ๋ฆฌ์ ๋ํ ์ค์ ๋น์ฉ ๊ฐ์ ๋งค์ฐ ๊ฐ๊น๋ค๋ ๊ฒ์ ์ ์ ์๋ค.
import matplotlib.pyplot as plt fig = plt.figure(figsize=(14, 10)) ax1 = fig.add_subplot(111) distance_vals = [x[4] for x in x_test.values] y_actual = y_test.values.flatten().tolist() ax1.scatter(distance_vals[:100], y_predict[:100], s=18, c='b', marker="s", label='Predicted') ax1.scatter(distance_vals[:100], y_actual[:100], s=18, c='r', marker="o", label='Actual') ax1.set_xlabel('distance (mi)') ax1.set_title('Predicted and Actual Cost/Distance') ax1.set_ylabel('Cost ($)') plt.legend(loc='upper left', prop={'size': 12}) plt.rcParams.update({'font.size': 14}) plt.show()
๊ฒฐ๊ณผ์ root mean squared error๋ฅผ ๊ณ์ฐํ๋ค.
y_test ๋ฐ์ดํฐ ํ๋ ์์ ์ฌ์ฉํ๊ณ ์ด๋ฅผ ๋ชฉ๋ก์ผ๋ก ๋ณํํ์ฌ ์์ธก ๊ฐ๊ณผ ๋น๊ตํ๋ค.
mean_squared_error ํจ์๋ ๋ ๊ฐ์ ๊ฐ ๋ฐฐ์ด์ ์ฌ์ฉํ๊ณ ๋ ๋ฐฐ์ด ๊ฐ์ ํ๊ท ์ ๊ณฑ ์ค์ฐจ๋ฅผ ๊ณ์ฐํ๋ค.
๊ฒฐ๊ณผ์ ์ ๊ณฑ๊ทผ์ ๊ตฌํ๋ฉด y ๋ณ์(๋น์ฉ)์ ๋์ผํ ๋จ์์์ ์ค๋ฅ๊ฐ ๋ํ๋๋ค.
์ด๋ ๋๋ต์ ์ผ๋ก ์ค์ ์๊ธ๊ณผ ํ์ ์๊ธ ์์ธก ๊ฐ ์ฐจ์ด๋ฅผ ๋ํ๋ธ๋ค. $3.2??
from sklearn.metrics import mean_squared_error from math import sqrt rmse = sqrt(mean_squared_error(y_actual, y_predict)) rmse
3.2204936862688798
์ ์ฒด y_actual ๋ฐ y_predict ๋ฐ์ดํฐ ์ธํธ๋ฅผ ์ฌ์ฉํ์ฌ MAPE(์ ๋ ํ๊ท ๋ฐฑ๋ถ์จ ์ค์ฐจ)๋ฅผ ๊ณ์ฐํ๋ ค๋ฉด ๋ค์ ์ฝ๋๋ฅผ ์คํํ๋ค.
์ด ๋ฉํธ๋ฆญ์ ๊ฐ ์์ธก ๋ฐ ์ค์ ๊ฐ ์ฌ์ด ์ ๋๊ฐ ์ฐจ์ด๋ฅผ ๊ณ์ฐํ๋ฉฐ ๋ชจ๋ ์ฐจ์ด๋ฅผ ํฉ์ฐํ๋ค.
๊ทธ๋ฐ ๋ค์, ์ค์ ๊ฐ์ ํฉ๊ณ์ ๋ํ ๋ฐฑ๋ถ์จ๋ก ํด๋น ํฉ์ฐ์ ํํํ๋ค.
sum_actuals = sum_errors = 0 for actual_val, predict_val in zip(y_actual, y_predict): abs_error = actual_val - predict_val if abs_error < 0: abs_error = abs_error * -1 sum_errors = sum_errors + abs_error sum_actuals = sum_actuals + actual_val mean_abs_percent_error = sum_errors / sum_actuals print("Model MAPE:") print(mean_abs_percent_error) print() print("Model Accuracy:") print(1 - mean_abs_percent_error)
Model MAPE: 0.10545153869569586 Model Accuracy: 0.8945484613043041
์ต์ข ์์ธก ์ ํ๋ ๋ฉํธ๋ฆญ์์ ๋ชจ๋ธ์ ๋ฐ์ดํฐ ์ธํธ์ ๊ธฐ๋ฅ์์ ํ์ ์๊ธ์ ์์ธกํ๋ ๋ฐ ์ ํฉํ๋ค๋ ๊ฒ์ ์ ์ ์๋ค. (์ผ๋ฐ์ ์ผ๋ก +- $3.00 ๋ด).
๊ธฐ์กด์ Machine Learning ๋ชจ๋ธ ๊ฐ๋ฐ ํ๋ก์ธ์ค๋ ๋ฆฌ์์ค๊ฐ ์๋นํ ๋ง์ด ํ์ํ๋ฉฐ, ์์ญ ๊ฐ์ง ๋ชจ๋ธ์ ์คํํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋น๊ตํ๋ ๋ฐ ๋ง์ ๋๋ฉ์ธ ์ง์๊ณผ ์๊ฐ์ด ํ์ํ๋ฐ, ์๋ํ๋ ๊ธฐ๊ณ ํ์ต์ ์ฌ์ฉํ๋ ๊ฒ์ ์๋๋ฆฌ์ค์ ๋ํ ๋ค๋ฅธ ์ฌ๋ฌ ๋ชจ๋ธ์ ์ ์ํ๊ฒ ํ ์คํธํ๋ ์ข์ ๋ฐฉ๋ฒ์ด๋ค.
'Machine Learning > Azure ML' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฐ์ดํฐ ๋ก๋ (0) | 2019.07.22 |
---|---|
Azure ML ์์ (0) | 2019.06.25 |
AKS ํด๋ฌ์คํฐ ๋ง๋ค๊ธฐ (0) | 2019.06.25 |