🥇MLflow ಜೊತೆಗೆ ವಿಸ್ತರಿಸುವ ಸ್ಪಾರ್ಕ್

ಹಲೋ, ಖಬ್ರೋವ್ಸ್ಕ್ ನಿವಾಸಿಗಳು. ನಾವು ಈಗಾಗಲೇ ಬರೆದಂತೆ, ಈ ತಿಂಗಳು OTUS ಎರಡು ಯಂತ್ರ ಕಲಿಕೆ ಕೋರ್ಸ್‌ಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪ್ರಾರಂಭಿಸುತ್ತಿದೆ, ಅವುಗಳೆಂದರೆ ಬೇಸ್ и ಮುಂದುವರಿದ. ಈ ನಿಟ್ಟಿನಲ್ಲಿ, ನಾವು ಉಪಯುಕ್ತ ವಸ್ತುಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತೇವೆ.

ಈ ಲೇಖನದ ಉದ್ದೇಶವು ಬಳಸಿದ ನಮ್ಮ ಮೊದಲ ಅನುಭವದ ಬಗ್ಗೆ ಮಾತನಾಡುವುದು ಎಂಎಲ್‌ಫ್ಲೋ.

ನಾವು ವಿಮರ್ಶೆಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ ಎಂಎಲ್‌ಫ್ಲೋ ಅದರ ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್‌ನಿಂದ ಮತ್ತು ಅಧ್ಯಯನದ ಎಲ್ಲಾ ಪುನರಾವರ್ತನೆಗಳನ್ನು ಲಾಗ್ ಮಾಡಿ. ನಂತರ ನಾವು UDF ಅನ್ನು ಬಳಸಿಕೊಂಡು MLflow ಜೊತೆಗೆ ಸ್ಪಾರ್ಕ್ ಅನ್ನು ಸಂಪರ್ಕಿಸುವ ನಮ್ಮ ಅನುಭವವನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತೇವೆ.

ಸಂದರ್ಭ

ನಾವು ಇದ್ದೇವೆ ಆಲ್ಫಾ ಆರೋಗ್ಯ ಜನರು ತಮ್ಮ ಆರೋಗ್ಯ ಮತ್ತು ಯೋಗಕ್ಷೇಮದ ಉಸ್ತುವಾರಿ ವಹಿಸಿಕೊಳ್ಳಲು ಅಧಿಕಾರ ನೀಡಲು ನಾವು ಯಂತ್ರ ಕಲಿಕೆ ಮತ್ತು ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯನ್ನು ಬಳಸುತ್ತೇವೆ. ಅದಕ್ಕಾಗಿಯೇ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಗಳು ನಾವು ಅಭಿವೃದ್ಧಿಪಡಿಸುವ ಡೇಟಾ ವಿಜ್ಞಾನ ಉತ್ಪನ್ನಗಳ ಹೃದಯಭಾಗದಲ್ಲಿವೆ ಮತ್ತು ಅದಕ್ಕಾಗಿಯೇ ನಾವು MLflow ಗೆ ಸೆಳೆಯಲ್ಪಟ್ಟಿದ್ದೇವೆ, ಇದು ಯಂತ್ರ ಕಲಿಕೆಯ ಜೀವನಚಕ್ರದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಮುಕ್ತ ಮೂಲ ವೇದಿಕೆಯಾಗಿದೆ.

ಎಂಎಲ್‌ಫ್ಲೋ

MLflow ನ ಮುಖ್ಯ ಗುರಿಯು ಯಂತ್ರ ಕಲಿಕೆಯ ಮೇಲೆ ಹೆಚ್ಚುವರಿ ಪದರವನ್ನು ಒದಗಿಸುವುದು, ಅದು ಡೇಟಾ ವಿಜ್ಞಾನಿಗಳು ಯಾವುದೇ ಯಂತ್ರ ಕಲಿಕೆ ಗ್ರಂಥಾಲಯದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ (h2o, ಕೆರಾಸ್, ಜಿಗಿತ, ಪೈಟೋರ್ಚ್, ಸಿಪ್ಪೆಸುಲಿಯಿರಿ и ಟೆನ್ಸರ್ಫ್ಲೋ), ಅವಳ ಕೆಲಸವನ್ನು ಮುಂದಿನ ಹಂತಕ್ಕೆ ಕೊಂಡೊಯ್ಯುವುದು.

MLflow ಮೂರು ಘಟಕಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:

ಟ್ರ್ಯಾಕಿಂಗ್ - ರೆಕಾರ್ಡಿಂಗ್ ಮತ್ತು ಪ್ರಯೋಗಗಳಿಗಾಗಿ ವಿನಂತಿಗಳು: ಕೋಡ್, ಡೇಟಾ, ಕಾನ್ಫಿಗರೇಶನ್ ಮತ್ತು ಫಲಿತಾಂಶಗಳು. ಮಾದರಿಯನ್ನು ರಚಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುವುದು ಬಹಳ ಮುಖ್ಯ.
ಯೋಜನೆಗಳು - ಯಾವುದೇ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಲು ಪ್ಯಾಕೇಜಿಂಗ್ ಫಾರ್ಮ್ಯಾಟ್ (ಉದಾ. ಸೇಜ್ ಮೇಕರ್)
ಮಾದರಿಗಳು - ವಿವಿಧ ನಿಯೋಜನೆ ಸಾಧನಗಳಿಗೆ ಮಾದರಿಗಳನ್ನು ಸಲ್ಲಿಸಲು ಸಾಮಾನ್ಯ ಸ್ವರೂಪ.

MLflow (ಬರೆಯುವ ಸಮಯದಲ್ಲಿ ಆಲ್ಫಾದಲ್ಲಿ) ತೆರೆದ ಮೂಲ ವೇದಿಕೆಯಾಗಿದ್ದು ಅದು ಪ್ರಯೋಗ, ಮರುಬಳಕೆ ಮತ್ತು ನಿಯೋಜನೆ ಸೇರಿದಂತೆ ಯಂತ್ರ ಕಲಿಕೆಯ ಜೀವನಚಕ್ರವನ್ನು ನಿರ್ವಹಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.

MLflow ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

MLflow ಅನ್ನು ಬಳಸಲು ನೀವು ಮೊದಲು ನಿಮ್ಮ ಸಂಪೂರ್ಣ ಪೈಥಾನ್ ಪರಿಸರವನ್ನು ಹೊಂದಿಸಬೇಕಾಗುತ್ತದೆ, ಇದಕ್ಕಾಗಿ ನಾವು ಬಳಸುತ್ತೇವೆ PyEnv (Mac ನಲ್ಲಿ ಪೈಥಾನ್ ಅನ್ನು ಸ್ಥಾಪಿಸಲು, ಪರಿಶೀಲಿಸಿ ಇಲ್ಲಿ) ಈ ರೀತಿಯಾಗಿ ನಾವು ವರ್ಚುವಲ್ ಪರಿಸರವನ್ನು ರಚಿಸಬಹುದು, ಅಲ್ಲಿ ನಾವು ಅದನ್ನು ಚಲಾಯಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಲೈಬ್ರರಿಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತೇವೆ.

```
pyenv install 3.7.0
pyenv global 3.7.0 # Use Python 3.7
mkvirtualenv mlflow # Create a Virtual Env with Python 3.7
workon mlflow
```

ಅಗತ್ಯವಿರುವ ಗ್ರಂಥಾಲಯಗಳನ್ನು ಸ್ಥಾಪಿಸೋಣ.

```
pip install mlflow==0.7.0 
            Cython==0.29  
            numpy==1.14.5 
            pandas==0.23.4 
            pyarrow==0.11.0
```

ಗಮನಿಸಿ: UDF ನಂತಹ ಮಾದರಿಗಳನ್ನು ಚಲಾಯಿಸಲು ನಾವು PyArrow ಅನ್ನು ಬಳಸುತ್ತೇವೆ. PyArrow ಮತ್ತು Numpy ನ ಆವೃತ್ತಿಗಳನ್ನು ಸರಿಪಡಿಸುವ ಅಗತ್ಯವಿದೆ ಏಕೆಂದರೆ ನಂತರದ ಆವೃತ್ತಿಗಳು ಪರಸ್ಪರ ಸಂಘರ್ಷವನ್ನು ಹೊಂದಿವೆ.

ಟ್ರ್ಯಾಕಿಂಗ್ UI ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ

MLflow ಟ್ರ್ಯಾಕಿಂಗ್ ನಮಗೆ ಪೈಥಾನ್ ಮತ್ತು ಬಳಸಿಕೊಂಡು ಪ್ರಯೋಗಗಳನ್ನು ಲಾಗ್ ಮಾಡಲು ಮತ್ತು ಪ್ರಶ್ನಿಸಲು ಅನುಮತಿಸುತ್ತದೆ ಉಳಿದ API. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಮಾದರಿ ಕಲಾಕೃತಿಗಳನ್ನು ಎಲ್ಲಿ ಸಂಗ್ರಹಿಸಬೇಕೆಂದು ನೀವು ನಿರ್ಧರಿಸಬಹುದು (ಸ್ಥಳೀಯ ಹೋಸ್ಟ್, ಅಮೆಜಾನ್ ಎಸ್ಎಕ್ಸ್ಎನ್ಎಕ್ಸ್, ಅಜುರೆ ಬ್ಲಾಬ್ ಸಂಗ್ರಹಣೆ, Google ಮೇಘ ಸಂಗ್ರಹಣೆ ಅಥವಾ SFTP ಸರ್ವರ್) ನಾವು ಆಲ್ಫಾ ಹೆಲ್ತ್‌ನಲ್ಲಿ AWS ಅನ್ನು ಬಳಸುವುದರಿಂದ, ನಮ್ಮ ಕಲಾಕೃತಿ ಸಂಗ್ರಹಣೆ S3 ಆಗಿರುತ್ತದೆ.

# Running a Tracking Server
mlflow server 
    --file-store /tmp/mlflow/fileStore 
    --default-artifact-root s3://<bucket>/mlflow/artifacts/ 
    --host localhost
    --port 5000

MLflow ನಿರಂತರ ಫೈಲ್ ಸಂಗ್ರಹಣೆಯನ್ನು ಬಳಸಲು ಶಿಫಾರಸು ಮಾಡುತ್ತದೆ. ಫೈಲ್ ಸಂಗ್ರಹಣೆ ಎಂದರೆ ಸರ್ವರ್ ರನ್ ಮತ್ತು ಪ್ರಯೋಗ ಮೆಟಾಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವಾಗ, ಅದು ನಿರಂತರ ಫೈಲ್ ಸ್ಟೋರ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಇಲ್ಲಿ ಪ್ರಯೋಗಕ್ಕಾಗಿ ನಾವು ಸರಳವಾಗಿ ಬಳಸುತ್ತೇವೆ /tmp.

ಹಳೆಯ ಪ್ರಯೋಗಗಳನ್ನು ಚಲಾಯಿಸಲು ನಾವು mlflow ಸರ್ವರ್ ಅನ್ನು ಬಳಸಲು ಬಯಸಿದರೆ, ಅವು ಫೈಲ್ ಸಂಗ್ರಹಣೆಯಲ್ಲಿ ಇರಬೇಕು ಎಂಬುದನ್ನು ನೆನಪಿಡಿ. ಆದಾಗ್ಯೂ, ಇದು ಇಲ್ಲದೆ ನಾವು ಅವುಗಳನ್ನು ಯುಡಿಎಫ್‌ನಲ್ಲಿ ಬಳಸಬಹುದು, ಏಕೆಂದರೆ ನಮಗೆ ಮಾದರಿಯ ಮಾರ್ಗ ಮಾತ್ರ ಬೇಕಾಗುತ್ತದೆ.

ಗಮನಿಸಿ: ಟ್ರ್ಯಾಕಿಂಗ್ UI ಮತ್ತು ಮಾದರಿ ಕ್ಲೈಂಟ್ ಕಲಾಕೃತಿಯ ಸ್ಥಳಕ್ಕೆ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರಬೇಕು ಎಂಬುದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ. ಅಂದರೆ, ಟ್ರ್ಯಾಕಿಂಗ್ UI EC2 ನಿದರ್ಶನದಲ್ಲಿ ನೆಲೆಸಿದ್ದರೂ, ಸ್ಥಳೀಯವಾಗಿ MLflow ಅನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ, ಕಲಾಕೃತಿ ಮಾದರಿಗಳನ್ನು ಬರೆಯಲು ಯಂತ್ರವು S3 ಗೆ ನೇರ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರಬೇಕು.

ಟ್ರ್ಯಾಕಿಂಗ್ UI S3 ಬಕೆಟ್‌ನಲ್ಲಿ ಕಲಾಕೃತಿಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ

ಚಾಲನೆಯಲ್ಲಿರುವ ಮಾದರಿಗಳು

ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್ ಚಾಲನೆಯಲ್ಲಿರುವ ತಕ್ಷಣ, ನೀವು ಮಾದರಿಗಳಿಗೆ ತರಬೇತಿ ನೀಡಲು ಪ್ರಾರಂಭಿಸಬಹುದು.

ಉದಾಹರಣೆಯಾಗಿ, ನಾವು MLflow ಉದಾಹರಣೆಯಿಂದ ವೈನ್ ಮಾರ್ಪಾಡನ್ನು ಬಳಸುತ್ತೇವೆ ಸ್ಕ್ಲೀರ್ನ್.

MLFLOW_TRACKING_URI=http://localhost:5000 python wine_quality.py 
  --alpha 0.9
  --l1_ration 0.5
  --wine_file ./data/winequality-red.csv

ನಾವು ಈಗಾಗಲೇ ಚರ್ಚಿಸಿದಂತೆ, MLflow ಮಾದರಿಯ ನಿಯತಾಂಕಗಳು, ಮೆಟ್ರಿಕ್‌ಗಳು ಮತ್ತು ಕಲಾಕೃತಿಗಳನ್ನು ಲಾಗ್ ಮಾಡಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ ಆದ್ದರಿಂದ ಅವು ಪುನರಾವರ್ತನೆಗಳ ಮೇಲೆ ಹೇಗೆ ವಿಕಸನಗೊಳ್ಳುತ್ತವೆ ಎಂಬುದನ್ನು ನೀವು ಟ್ರ್ಯಾಕ್ ಮಾಡಬಹುದು. ಈ ವೈಶಿಷ್ಟ್ಯವು ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿದೆ ಏಕೆಂದರೆ ಈ ರೀತಿಯಲ್ಲಿ ನಾವು ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್ ಅನ್ನು ಸಂಪರ್ಕಿಸುವ ಮೂಲಕ ಅಥವಾ ಕಮಿಟ್‌ಗಳ git ಹ್ಯಾಶ್ ಲಾಗ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅಗತ್ಯವಿರುವ ಪುನರಾವರ್ತನೆಯನ್ನು ಯಾವ ಕೋಡ್ ಪೂರ್ಣಗೊಳಿಸಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಉತ್ತಮ ಮಾದರಿಯನ್ನು ಪುನರುತ್ಪಾದಿಸಬಹುದು.

with mlflow.start_run():

    ... model ...

    mlflow.log_param("source", wine_path)
    mlflow.log_param("alpha", alpha)
    mlflow.log_param("l1_ratio", l1_ratio)

    mlflow.log_metric("rmse", rmse)
    mlflow.log_metric("r2", r2)
    mlflow.log_metric("mae", mae)

    mlflow.set_tag('domain', 'wine')
    mlflow.set_tag('predict', 'quality')
    mlflow.sklearn.log_model(lr, "model")

ವೈನ್ ಪುನರಾವರ್ತನೆಗಳು

ಮಾದರಿಗಾಗಿ ಸರ್ವರ್ ಭಾಗ

"mlflow ಸರ್ವರ್" ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪ್ರಾರಂಭಿಸಲಾದ MLflow ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್, ರನ್‌ಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಮತ್ತು ಸ್ಥಳೀಯ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ಗೆ ಡೇಟಾವನ್ನು ಬರೆಯಲು REST API ಅನ್ನು ಹೊಂದಿದೆ. ಪರಿಸರ ವೇರಿಯೇಬಲ್ "MLFLOW_TRACKING_URI" ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್ ವಿಳಾಸವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ಮತ್ತು MLflow ಟ್ರ್ಯಾಕಿಂಗ್ API ಈ ವಿಳಾಸದಲ್ಲಿ ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್ ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಲಾಂಚ್ ಮಾಹಿತಿ, ಲಾಗ್ ಮೆಟ್ರಿಕ್‌ಗಳು ಇತ್ಯಾದಿಗಳನ್ನು ರಚಿಸಲು/ಸ್ವೀಕರಿಸಲು ಸಂಪರ್ಕಿಸುತ್ತದೆ.

ಮೂಲ: ಡಾಕ್ಸ್// ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್ ಅನ್ನು ರನ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಸರ್ವರ್‌ನೊಂದಿಗೆ ಮಾದರಿಯನ್ನು ಒದಗಿಸಲು, ನಮಗೆ ಚಾಲನೆಯಲ್ಲಿರುವ ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್ (ಉಡಾವಣಾ ಇಂಟರ್ಫೇಸ್ ನೋಡಿ) ಮತ್ತು ಮಾದರಿಯ ರನ್ ಐಡಿ ಅಗತ್ಯವಿದೆ.

ID ಅನ್ನು ರನ್ ಮಾಡಿ

# Serve a sklearn model through 127.0.0.0:5005
MLFLOW_TRACKING_URI=http://0.0.0.0:5000 mlflow sklearn serve 
  --port 5005  
  --run_id 0f8691808e914d1087cf097a08730f17 
  --model-path model

MLflow ಸರ್ವ್ ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಮಾದರಿಗಳನ್ನು ಪೂರೈಸಲು, ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಮೂಲಕ ಮಾದರಿಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸ್ವೀಕರಿಸಲು ನಮಗೆ ಟ್ರ್ಯಾಕಿಂಗ್ UI ಗೆ ಪ್ರವೇಶದ ಅಗತ್ಯವಿದೆ --run_id.

ಒಮ್ಮೆ ಮಾದರಿಯು ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್ ಅನ್ನು ಸಂಪರ್ಕಿಸಿದ ನಂತರ, ನಾವು ಹೊಸ ಮಾದರಿಯ ಅಂತಿಮ ಬಿಂದುವನ್ನು ಪಡೆಯಬಹುದು.

# Query Tracking Server Endpoint
curl -X POST 
  http://127.0.0.1:5005/invocations 
  -H 'Content-Type: application/json' 
  -d '[
	{
		"fixed acidity": 3.42, 
		"volatile acidity": 1.66, 
		"citric acid": 0.48, 
		"residual sugar": 4.2, 
		"chloridessssss": 0.229, 
		"free sulfur dsioxide": 19, 
		"total sulfur dioxide": 25, 
		"density": 1.98, 
		"pH": 5.33, 
		"sulphates": 4.39, 
		"alcohol": 10.8
	}
]'

> {"predictions": [5.825055635303461]}

ಸ್ಪಾರ್ಕ್‌ನಿಂದ ಚಾಲನೆಯಲ್ಲಿರುವ ಮಾದರಿಗಳು

ನೈಜ ಸಮಯದಲ್ಲಿ ಮಾದರಿಗಳನ್ನು ಪೂರೈಸಲು, ಅವರಿಗೆ ತರಬೇತಿ ನೀಡಲು ಮತ್ತು ಸರ್ವರ್ ಕಾರ್ಯವನ್ನು ಬಳಸಲು ಟ್ರ್ಯಾಕಿಂಗ್ ಸರ್ವರ್ ಸಾಕಷ್ಟು ಶಕ್ತಿಯುತವಾಗಿದೆ ಎಂಬ ವಾಸ್ತವದ ಹೊರತಾಗಿಯೂ (ಮೂಲ: mlflow // ಡಾಕ್ಸ್ // ಮಾದರಿಗಳು # ಸ್ಥಳೀಯ), ಸ್ಪಾರ್ಕ್ (ಬ್ಯಾಚ್ ಅಥವಾ ಸ್ಟ್ರೀಮಿಂಗ್) ಬಳಕೆಯು ವಿತರಣೆಯಿಂದಾಗಿ ಇನ್ನೂ ಹೆಚ್ಚು ಶಕ್ತಿಯುತ ಪರಿಹಾರವಾಗಿದೆ.

ನೀವು ಕೇವಲ ಆಫ್‌ಲೈನ್‌ನಲ್ಲಿ ತರಬೇತಿಯನ್ನು ಮಾಡಿದ್ದೀರಿ ಮತ್ತು ನಂತರ ನಿಮ್ಮ ಎಲ್ಲಾ ಡೇಟಾಗೆ ಔಟ್‌ಪುಟ್ ಮಾದರಿಯನ್ನು ಅನ್ವಯಿಸಿದ್ದೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಇಲ್ಲಿ ಸ್ಪಾರ್ಕ್ ಮತ್ತು ಎಂಎಲ್‌ಫ್ಲೋ ಹೊಳೆಯುತ್ತದೆ.

PySpark + Jupyter + Spark ಅನ್ನು ಸ್ಥಾಪಿಸಿ

ಮೂಲ: ಪ್ರಾರಂಭಿಸಿ PySpark - Jupyter

ನಾವು Spark ಡೇಟಾಫ್ರೇಮ್‌ಗಳಿಗೆ MLflow ಮಾದರಿಗಳನ್ನು ಹೇಗೆ ಅನ್ವಯಿಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ತೋರಿಸಲು, PySpark ಜೊತೆಗೆ ಕೆಲಸ ಮಾಡಲು ನಾವು Jupyter ನೋಟ್‌ಬುಕ್‌ಗಳನ್ನು ಹೊಂದಿಸಬೇಕಾಗಿದೆ.

ಇತ್ತೀಚಿನ ಸ್ಥಿರ ಆವೃತ್ತಿಯನ್ನು ಸ್ಥಾಪಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭಿಸಿ ಅಪಾಚೆ ಸ್ಪಾರ್ಕ್:

cd ~/Downloads/
tar -xzf spark-2.4.3-bin-hadoop2.7.tgz
mv ~/Downloads/spark-2.4.3-bin-hadoop2.7 ~/
ln -s ~/spark-2.4.3-bin-hadoop2.7 ~/spark̀

ವರ್ಚುವಲ್ ಪರಿಸರದಲ್ಲಿ PySpark ಮತ್ತು Jupyter ಅನ್ನು ಸ್ಥಾಪಿಸಿ:

pip install pyspark jupyter

ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಹೊಂದಿಸಿ:

export SPARK_HOME=~/spark
export PATH=$SPARK_HOME/bin:$PATH
export PYSPARK_DRIVER_PYTHON=jupyter
export PYSPARK_DRIVER_PYTHON_OPTS="notebook --notebook-dir=${HOME}/Projects/notebooks"

ನಿರ್ಧರಿಸಿದ ನಂತರ notebook-dir, ನಾವು ನಮ್ಮ ನೋಟ್‌ಬುಕ್‌ಗಳನ್ನು ಬಯಸಿದ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು.

ಪೈಸ್ಪಾರ್ಕ್‌ನಿಂದ ಜುಪಿಟರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ

ನಾವು ಜುಪಿಟರ್ ಅನ್ನು ಪೈಸ್ಪಾರ್ಕ್ ಡ್ರೈವರ್ ಆಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗಿರುವುದರಿಂದ, ನಾವು ಈಗ ಪೈಸ್ಪಾರ್ಕ್ ಸಂದರ್ಭದಲ್ಲಿ ಜುಪಿಟರ್ ನೋಟ್‌ಬುಕ್ ಅನ್ನು ರನ್ ಮಾಡಬಹುದು.

(mlflow) afranzi:~$ pyspark
[I 19:05:01.572 NotebookApp] sparkmagic extension enabled!
[I 19:05:01.573 NotebookApp] Serving notebooks from local directory: /Users/afranzi/Projects/notebooks
[I 19:05:01.573 NotebookApp] The Jupyter Notebook is running at:
[I 19:05:01.573 NotebookApp] http://localhost:8888/?token=c06252daa6a12cfdd33c1d2e96c8d3b19d90e9f6fc171745
[I 19:05:01.573 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).
[C 19:05:01.574 NotebookApp]

    Copy/paste this URL into your browser when you connect for the first time,
    to login with a token:
        http://localhost:8888/?token=c06252daa6a12cfdd33c1d2e96c8d3b19d90e9f6fc171745

ಮೇಲೆ ಹೇಳಿದಂತೆ, S3 ನಲ್ಲಿ ಮಾದರಿ ಕಲಾಕೃತಿಗಳನ್ನು ಲಾಗಿಂಗ್ ಮಾಡಲು MLflow ವೈಶಿಷ್ಟ್ಯವನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಮ್ಮ ಕೈಯಲ್ಲಿ ಆಯ್ಕೆಮಾಡಿದ ಮಾದರಿಯನ್ನು ಹೊಂದಿದ ತಕ್ಷಣ, ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು UDF ಆಗಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಲು ನಮಗೆ ಅವಕಾಶವಿದೆ mlflow.pyfunc.

import mlflow.pyfunc

model_path = 's3://<bucket>/mlflow/artifacts/1/0f8691808e914d1087cf097a08730f17/artifacts/model'
wine_path = '/Users/afranzi/Projects/data/winequality-red.csv'
wine_udf = mlflow.pyfunc.spark_udf(spark, model_path)

df = spark.read.format("csv").option("header", "true").option('delimiter', ';').load(wine_path)
columns = [ "fixed acidity", "volatile acidity", "citric acid",
            "residual sugar", "chlorides", "free sulfur dioxide",
            "total sulfur dioxide", "density", "pH",
            "sulphates", "alcohol"
          ]
          
df.withColumn('prediction', wine_udf(*columns)).show(100, False)

PySpark - ವೈನ್ ಗುಣಮಟ್ಟದ ಮುನ್ನೋಟಗಳನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುವುದು

ಈ ಹಂತದವರೆಗೆ, MLflow ಜೊತೆಗೆ PySpark ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದರ ಕುರಿತು ನಾವು ಮಾತನಾಡಿದ್ದೇವೆ, ಸಂಪೂರ್ಣ ವೈನ್ ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ವೈನ್ ಗುಣಮಟ್ಟದ ಮುನ್ನೋಟಗಳನ್ನು ಚಾಲನೆ ಮಾಡುತ್ತಿದ್ದೇವೆ. ಆದರೆ ನೀವು ಸ್ಕಾಲಾ ಸ್ಪಾರ್ಕ್‌ನಿಂದ ಪೈಥಾನ್ ಎಂಎಲ್‌ಫ್ಲೋ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಬಳಸಬೇಕಾದರೆ ಏನು ಮಾಡಬೇಕು?

ಸ್ಕಾಲಾ ಮತ್ತು ಪೈಥಾನ್ ನಡುವೆ ಸ್ಪಾರ್ಕ್ ಸಂದರ್ಭವನ್ನು ವಿಭಜಿಸುವ ಮೂಲಕ ನಾವು ಇದನ್ನು ಪರೀಕ್ಷಿಸಿದ್ದೇವೆ. ಅಂದರೆ, ನಾವು ಪೈಥಾನ್‌ನಲ್ಲಿ MLflow UDF ಅನ್ನು ನೋಂದಾಯಿಸಿದ್ದೇವೆ ಮತ್ತು ಅದನ್ನು ಸ್ಕಾಲಾದಿಂದ ಬಳಸಿದ್ದೇವೆ (ಹೌದು, ಬಹುಶಃ ಉತ್ತಮ ಪರಿಹಾರವಲ್ಲ, ಆದರೆ ನಾವು ಹೊಂದಿದ್ದೇವೆ).

ಸ್ಕಲಾ ಸ್ಪಾರ್ಕ್ + ಎಂಎಲ್ ಫ್ಲೋ

ಈ ಉದಾಹರಣೆಗಾಗಿ ನಾವು ಸೇರಿಸುತ್ತೇವೆ ಟೋರಿ ಕರ್ನಲ್ ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಗುರುವಿನೊಳಗೆ.

Spark + Toree + Jupyter ಅನ್ನು ಸ್ಥಾಪಿಸಿ

pip install toree
jupyter toree install --spark_home=${SPARK_HOME} --sys-prefix
jupyter kernelspec list
```
```
Available kernels:
  apache_toree_scala    /Users/afranzi/.virtualenvs/mlflow/share/jupyter/kernels/apache_toree_scala
  python3               /Users/afranzi/.virtualenvs/mlflow/share/jupyter/kernels/python3
```

ಲಗತ್ತಿಸಲಾದ ನೋಟ್‌ಬುಕ್‌ನಿಂದ ನೀವು ನೋಡುವಂತೆ, UDF ಅನ್ನು ಸ್ಪಾರ್ಕ್ ಮತ್ತು ಪೈಸ್ಪಾರ್ಕ್ ನಡುವೆ ಹಂಚಿಕೊಳ್ಳಲಾಗಿದೆ. ಸ್ಕಾಲಾವನ್ನು ಇಷ್ಟಪಡುವವರಿಗೆ ಮತ್ತು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಯಂತ್ರ ಕಲಿಕೆಯ ಮಾದರಿಗಳನ್ನು ನಿಯೋಜಿಸಲು ಬಯಸುವವರಿಗೆ ಈ ಭಾಗವು ಉಪಯುಕ್ತವಾಗಿದೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ.

import org.apache.spark.sql.functions.col
import org.apache.spark.sql.types.StructType
import org.apache.spark.sql.{Column, DataFrame}
import scala.util.matching.Regex

val FirstAtRe: Regex = "^_".r
val AliasRe: Regex = "[\s_.:@]+".r

def getFieldAlias(field_name: String): String = {
    FirstAtRe.replaceAllIn(AliasRe.replaceAllIn(field_name, "_"), "")
}

def selectFieldsNormalized(columns: List[String])(df: DataFrame): DataFrame = {
    val fieldsToSelect: List[Column] = columns.map(field =>
        col(field).as(getFieldAlias(field))
    )
    df.select(fieldsToSelect: _*)
}

def normalizeSchema(df: DataFrame): DataFrame = {
    val schema = df.columns.toList
    df.transform(selectFieldsNormalized(schema))
}

FirstAtRe = ^_
AliasRe = [s_.:@]+

getFieldAlias: (field_name: String)String
selectFieldsNormalized: (columns: List[String])(df: org.apache.spark.sql.DataFrame)org.apache.spark.sql.DataFrame
normalizeSchema: (df: org.apache.spark.sql.DataFrame)org.apache.spark.sql.DataFrame
Out[1]:
[s_.:@]+
In [2]:
val winePath = "~/Research/mlflow-workshop/examples/wine_quality/data/winequality-red.csv"
val modelPath = "/tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model"

winePath = ~/Research/mlflow-workshop/examples/wine_quality/data/winequality-red.csv
modelPath = /tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model
Out[2]:
/tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model
In [3]:
val df = spark.read
              .format("csv")
              .option("header", "true")
              .option("delimiter", ";")
              .load(winePath)
              .transform(normalizeSchema)

df = [fixed_acidity: string, volatile_acidity: string ... 10 more fields]
Out[3]:
[fixed_acidity: string, volatile_acidity: string ... 10 more fields]
In [4]:
%%PySpark
import mlflow
from mlflow import pyfunc

model_path = "/tmp/mlflow/artifactStore/0/96cba14c6e4b452e937eb5072467bf79/artifacts/model"
wine_quality_udf = mlflow.pyfunc.spark_udf(spark, model_path)

spark.udf.register("wineQuality", wine_quality_udf)
Out[4]:
<function spark_udf.<locals>.predict at 0x1116a98c8>
In [6]:
df.createOrReplaceTempView("wines")
In [10]:
%%SQL
SELECT 
    quality,
    wineQuality(
        fixed_acidity,
        volatile_acidity,
        citric_acid,
        residual_sugar,
        chlorides,
        free_sulfur_dioxide,
        total_sulfur_dioxide,
        density,
        pH,
        sulphates,
        alcohol
    ) AS prediction
FROM wines
LIMIT 10
Out[10]:
+-------+------------------+
|quality|        prediction|
+-------+------------------+
|      5| 5.576883967129615|
|      5|  5.50664776916154|
|      5| 5.525504822954496|
|      6| 5.504311247097457|
|      5| 5.576883967129615|
|      5|5.5556903912725755|
|      5| 5.467882654744997|
|      7| 5.710602976324739|
|      7| 5.657319539336507|
|      5| 5.345098606538708|
+-------+------------------+

In [17]:
spark.catalog.listFunctions.filter('name like "%wineQuality%").show(20, false)

+-----------+--------+-----------+---------+-----------+
|name       |database|description|className|isTemporary|
+-----------+--------+-----------+---------+-----------+
|wineQuality|null    |null       |null     |true       |
+-----------+--------+-----------+---------+-----------+

ಮುಂದಿನ ಹಂತಗಳು

MLflow ಬರೆಯುವ ಸಮಯದಲ್ಲಿ ಆಲ್ಫಾ ಆವೃತ್ತಿಯಲ್ಲಿದ್ದರೂ ಸಹ, ಇದು ಸಾಕಷ್ಟು ಭರವಸೆಯಂತೆ ಕಾಣುತ್ತದೆ. ಬಹು ಮೆಷಿನ್ ಲರ್ನಿಂಗ್ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳನ್ನು ಚಲಾಯಿಸುವ ಮತ್ತು ಒಂದೇ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ನಿಂದ ಅವುಗಳನ್ನು ಸೇವಿಸುವ ಸಾಮರ್ಥ್ಯವು ಶಿಫಾರಸು ಮಾಡುವ ವ್ಯವಸ್ಥೆಯನ್ನು ಮುಂದಿನ ಹಂತಕ್ಕೆ ಕೊಂಡೊಯ್ಯುತ್ತದೆ.

ಜೊತೆಗೆ, MLflow ಡೇಟಾ ಇಂಜಿನಿಯರ್‌ಗಳು ಮತ್ತು ಡೇಟಾ ಸೈನ್ಸ್ ತಜ್ಞರನ್ನು ಹತ್ತಿರಕ್ಕೆ ತರುತ್ತದೆ, ಅವುಗಳ ನಡುವೆ ಸಾಮಾನ್ಯ ಪದರವನ್ನು ಇಡುತ್ತದೆ.

MLflow ನ ಈ ಪರಿಶೋಧನೆಯ ನಂತರ, ನಾವು ಮುಂದುವರಿಯುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ನಮ್ಮ ಸ್ಪಾರ್ಕ್ ಪೈಪ್‌ಲೈನ್‌ಗಳು ಮತ್ತು ಶಿಫಾರಸು ಮಾಡುವ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಬಳಸುತ್ತೇವೆ ಎಂದು ನಮಗೆ ವಿಶ್ವಾಸವಿದೆ.

ಫೈಲ್ ಸಿಸ್ಟಮ್ ಬದಲಿಗೆ ಡೇಟಾಬೇಸ್ನೊಂದಿಗೆ ಫೈಲ್ ಸಂಗ್ರಹವನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವುದು ಒಳ್ಳೆಯದು. ಒಂದೇ ಫೈಲ್ ಸಂಗ್ರಹಣೆಯನ್ನು ಬಳಸಬಹುದಾದ ಬಹು ಅಂತಿಮ ಬಿಂದುಗಳನ್ನು ಇದು ನಮಗೆ ನೀಡುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಹಲವಾರು ನಿದರ್ಶನಗಳನ್ನು ಬಳಸಿ ಪ್ರೆಸ್ಟೋ и ಅಥೇನಾ ಅದೇ ಅಂಟು ಮೆಟಾಸ್ಟೋರ್ನೊಂದಿಗೆ.

ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೇಳುವುದಾದರೆ, ಡೇಟಾದೊಂದಿಗೆ ನಮ್ಮ ಕೆಲಸವನ್ನು ಹೆಚ್ಚು ಆಸಕ್ತಿಕರವಾಗಿಸಿದ್ದಕ್ಕಾಗಿ MLFlow ಸಮುದಾಯಕ್ಕೆ ನಾನು ಧನ್ಯವಾದ ಹೇಳಲು ಬಯಸುತ್ತೇನೆ.

ನೀವು MLflow ಜೊತೆಗೆ ಆಟವಾಡುತ್ತಿದ್ದರೆ, ನಮಗೆ ಬರೆಯಲು ಹಿಂಜರಿಯಬೇಡಿ ಮತ್ತು ನೀವು ಅದನ್ನು ಹೇಗೆ ಬಳಸುತ್ತೀರಿ ಎಂದು ನಮಗೆ ತಿಳಿಸಿ, ಮತ್ತು ಇನ್ನೂ ಹೆಚ್ಚಿನದನ್ನು ನೀವು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಬಳಸಿದರೆ.

ಕೋರ್ಸ್‌ಗಳ ಕುರಿತು ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಿ:
ಯಂತ್ರ ಕಲಿಕೆ. ಮೂಲ ಕೋರ್ಸ್
ಯಂತ್ರ ಕಲಿಕೆ. ಸುಧಾರಿತ ಕೋರ್ಸ್

ಮತ್ತಷ್ಟು ಓದು:

ಮೂಲ: www.habr.com

MLflow ಜೊತೆಗೆ ಸ್ಪಾರ್ಕ್ ಅನ್ನು ವಿಸ್ತರಿಸುವುದು