def init(): global model # note here "sklearn_regression_model.pkl" is the name of the model registered under # this is a different behavior than before when the code is run locally, even though the code is the same. model_path = Model.get_model_path('LOS_RF_model2.pkl') # deserialize the model file back into a sklearn model model = pickle.load(open(model_path, 'rb')) global inputs_dc, prediction_dc # this setup will help us save our inputs under the "inputs" path in our Azure Blob inputs_dc = ModelDataCollector( model_name="LOS_RF_model2.pkl", identifier="inputs", feature_names=[ 'rcount', 'gender', 'dialysisrenalendstage', 'asthma', 'irondef', 'pneum', 'substancedependence', 'psychologicaldisordermajor', 'depress', 'psychother', 'fibrosisandother', 'malnutrition', 'hemo', 'hematocrit', 'neutrophils', 'sodium', 'glucose', 'bloodureanitro', 'creatinine', 'bmi', 'pulse', 'respiration', 'secondarydiagnosisnonicd9', 'fid', 'Capacity', 'Name', 'daysofweek_admit' ]) # this setup will help us save our ipredictions under the "predictions" path in our Azure Blob prediction_dc = ModelDataCollector("LOS_RF_model2.pkl", identifier="predictions", feature_names=["prediction1"])
def init(): global model global inputs_dc, prediction_dc global tokenizer, max_len, max_words try: model_name = 'MODEL-NAME' # Placeholder model name print('Looking for model path for model: ', model_name) model_path = Model.get_model_path(model_name=model_name) print('Loading model from: ', model_path) # Load the ONNX model model = onnxruntime.InferenceSession(model_path) print('Model loaded...') inputs_dc = ModelDataCollector("model_telemetry", designation="inputs") prediction_dc = ModelDataCollector("model_telemetry", designation="predictions", feature_names=["prediction"]) car_components_descriptions = pd.read_csv( 'dataset/training_data.csv')['text'].tolist() print('Training dataset loaded...') max_len = 100 max_words = 10000 tokenizer = Tokenizer(num_words=max_words) tokenizer.fit_on_texts(car_components_descriptions) print('Tokenizer fitted...') except Exception as e: print(e)
def init(): global model, scaler, input_name, label_name, inputs_dc, prediction_dc scaler_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'model-scaler/1/model-scaler.pkl') # deserialize the model file back into a sklearn model scaler = joblib.load(scaler_path) model_onnx = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'support-vector-classifier/2/svc.onnx') # print(os.listdir(model_onnx)) model = onnxruntime.InferenceSession(model_onnx, None) input_name = model.get_inputs()[0].name label_name = model.get_outputs()[0].name # variables to monitor model input and output data inputs_dc = ModelDataCollector("Support vector classifier model", designation="inputs", feature_names=[ "feat1", "feat2", "feat3", "feat4", "feat5", "feat6", "feat7" ]) prediction_dc = ModelDataCollector("Support vector classifier model", designation="predictions", feature_names=["weatherprediction"])
def init(): try: # One-time initialization of PySpark and predictive model global trainedModel global spark global inputs_dc, prediction_dc model_name = "{model_name}" # interpolated model_path = Model.get_model_path(model_name) # hack to such that model_path can work with zip file. Reason is the image can only be created using zip file. # If no zip file was used, then every file in the unzipped file would create a layer and thus exceeding max depth layers (125) of docker mdl, ext = model_path.rsplit(".", 1) os.mkdir(mdl + ".tmp") shutil.unpack_archive(model_path, mdl + ".tmp") os.remove(model_path) os.rename(mdl + ".tmp", model_path) inputs_dc = ModelDataCollector(model_name, designation="inputs", feature_names=["json_input_data"]) prediction_dc = ModelDataCollector(model_name, designation="predictions", feature_names=["predictions"]) spark = pyspark.sql.SparkSession.builder.appName( "AML Production Model").getOrCreate() trainedModel = PipelineModel.load(model_path) except Exception as e: trainedModel = e
def init(): global model global inputs_dc, prediction_dc global tokenizer, max_len, max_words try: model_name = 'compliance-classifier' print('Looking for model path for model: ', model_name) model_path = Model.get_model_path(model_name = model_name) print('Loading model from: ', model_path) # Load the ONNX model model = onnxruntime.InferenceSession(model_path) print('Model loaded...') inputs_dc = ModelDataCollector("model_telemetry", designation="inputs") prediction_dc = ModelDataCollector("model_telemetry", designation="predictions", feature_names=["prediction"]) cardata_url = ('https://quickstartsws9073123377.blob.core.windows.net/' 'azureml-blobstore-0d1c4218-a5f9-418b-bf55-902b65277b85/' 'quickstarts/connected-car-data/connected-car_components.csv') car_components_descriptions = pd.read_csv(cardata_url)['text'].tolist() print('Training dataset loaded...') max_len = 100 max_words = 10000 tokenizer = Tokenizer(num_words = max_words) tokenizer.fit_on_texts(car_components_descriptions) print('Tokenizer fitted...') except Exception as e: print(e)
def init(): global model global inputs_dc, prediction_dc # The AZUREML_MODEL_DIR environment variable indicates a directory containing the model file you registered. model_file_name = "model.pkl" model_path = os.path.join(os.environ.get("AZUREML_MODEL_DIR"), model_file_name) model = joblib.load(model_path) inputs_dc = ModelDataCollector("sample-model", designation="inputs", feature_names=["feat1", "feat2", "feat3", "feat4"]) prediction_dc = ModelDataCollector("sample-model", designation="predictions", feature_names=["prediction"])
def init(): # Load model global model model_dir = os.getenv('AZUREML_MODEL_DIR') model_path = os.path.join(model_dir, 'credit-prediction.pkl') model = joblib.load(model_path) # Setup Data Collection global inputs_dc global predictions_dc inputs_dc = ModelDataCollector("best_model", designation="inputs", feature_names=["Age", "Sex", "Job", "Housing", "Saving accounts", "Checking account", "Credit amount", "Duration", "Purpose"]) predictions_dc = ModelDataCollector("best_model", designation="predictions", feature_names=["good", "bad"])
def init(): global model print ("model initialized" + time.strftime("%H:%M:%S")) # note here "sklearn_regression_model.pkl" is the name of the model registered under the workspace # this call should return the path to the model.pkl file on the local disk. model_path = Model.get_model_path(model_name = 'sklearn_regression_model') # deserialize the model file back into a sklearn model model = joblib.load(model_path) global inputs_dc, prediction_dc # this setup will help us save our inputs under the "inputs" path in our Azure Blob inputs_dc = ModelDataCollector(model_name="sklearn_regression_model", identifier="inputs", feature_names=["feat1", "feat2"]) # this setup will help us save our ipredictions under the "predictions" path in our Azure Blob prediction_dc = ModelDataCollector("sklearn_regression_model", identifier="predictions", feature_names=["prediction1", "prediction2"])
def init(): global model global inputs_dc, prediction_dc inputs_dc = ModelDataCollector("torchcnn", identifier="inputs") prediction_dc = ModelDataCollector("torchcnn", identifier="predictions") model = CNN() # The line below loads the model from the AML Service model_path = Model.get_model_path(model_name="torchcnn") # It is also possible to load a local model file # model_path = '/temp/torchcnn.pth' model.load_state_dict(torch.load(model_path)) model.eval()
def init(): global model global inputs_dc, prediction_dc inputs_dc = ModelDataCollector("model", identifier="inputs", feature_names=["feat1", "feat2", "feat3"]) prediction_dc = ModelDataCollector("model", identifier="predictions", feature_names=["prediction1"]) # note here "best_model" is the name of the model registered under the workspace # this call should return the path to the model.pkl file on the local disk. model_path = Model.get_model_path(model_name='model') # deserialize the model file back into a sklearn model model = joblib.load(model_path)
def init(): global model print("Model Initialized: " + time.strftime("%H:%M:%S")) # load the model from file into a global object model_path = Model.get_model_path(model_name="mymodel") model = joblib.load(model_path) print("Initialize Data Collectors") global inputs_dc, prediction_dc inputs_dc = ModelDataCollector(model_name="sklearn_regression_model", feature_names=[ "AGE", "SEX", "BMI", "BP", "S1", "S2", "S3", "S4", "S5", "S6" ]) prediction_dc = ModelDataCollector(model_name="sklearn_regression_model", feature_names=["Y"])
def init(): global model global inputs_dc, prediction_dc model_name = 'MODEL-NAME' # Placeholder model name print('Looking for model path for model: ', model_name) model_path = Model.get_model_path(model_name=model_name) print('Loading model from: ', model_path) with open(model_path, 'rb') as f: model = pickle.load(f) inputs_dc = ModelDataCollector("model_telemetry", designation="inputs") prediction_dc = ModelDataCollector("model_telemetry", designation="predictions", feature_names=["prediction"])
def init(): global logger global model global pred_collector init_logger() pred_collector = ModelDataCollector(MODEL_NAME, identifier="imgpred", feature_names=["detection"]) model = load_model()
def init(): global model global inputs_dc, prediction_dc model_path = Model.get_model_path(consts.model_name) model = joblib.load(model_path) inputs_dc = ModelDataCollector(consts.model_name, designation="inputs", feature_names=[ 'vendorID', 'passengerCount', 'tripDistance', 'pickupLongitude', 'pickupLatitude', 'dropoffLongitude', 'dropoffLatitude', 'totalAmount', 'month_num', 'day_of_month', 'day_of_week', 'hour_of_day' ]) prediction_dc = ModelDataCollector(consts.model_name, designation="predictions", feature_names=["duration"])
def init(): global model, scaler, input_name, label_name, inputs_dc, prediction_dc, tc # Add your telemetry key tc = TelemetryClient('xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxx') scaler_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'scaler/1/scaler.pkl') # deserialize the model file back into a sklearn model try: scaler = joblib.load(scaler_path) except Exception as e: tc.track_event('FileNotFoundException', {'error_message': str(e)}, {'FileNotFoundError': 101}) tc.flush() model_onnx = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'support-vector-classifier/1/svc.onnx') try: model = onnxruntime.InferenceSession(model_onnx, None) except Exception as e: tc.track_event('FileNotFoundException', {'error_message': str(e)}, {'FileNotFoundError': 101}) tc.flush() input_name = model.get_inputs()[0].name label_name = model.get_outputs()[0].name # variables to monitor model input and output data inputs_dc = ModelDataCollector("Support vector classifier model", designation="inputs", feature_names=[ "Temperature_C", "Humidity", "Wind_speed_kmph", "Wind_bearing_degrees", "Visibility_km", "Pressure_millibars", "Current_weather_condition" ]) prediction_dc = ModelDataCollector( "Support vector classifier model", designation="predictions", feature_names=["Future_weather_condition"])
def init(): global model global inputs_dc, prediction_dc try: model_name = 'MODEL-NAME' # Placeholder model name print('Looking for model path for model: ', model_name) model_path = Model.get_model_path(model_name=model_name) print('Loading model from: ', model_path) model = load_model(model_path) print("Model loaded from disk.") print(model.summary()) inputs_dc = ModelDataCollector("model_telemetry", designation="inputs") prediction_dc = ModelDataCollector("model_telemetry", designation="predictions", feature_names=["prediction"]) except Exception as e: print(e)
def init(): # Load model global model model_dir = os.getenv('AZUREML_MODEL_DIR') model_path = os.path.join(model_dir, 'aml-demo-model.pkl') model = joblib.load(model_path) # Setup Data Collection global data_collector data_collector = ModelDataCollector("prod_model", designation="inputs")
def init(): global learn model_file = Model.get_model_path("cats_vs_dogs") model_path = os.path.dirname(model_file) print(model_path) learn = load_learner(model_path) global prediction_dc prediction_dc = ModelDataCollector("best_model", identifier="predictions", feature_names=["prediction"])
def init(): ''' Initialize required models: Get the IRIS Model from Model Registry and load ''' global prediction_dc global model prediction_dc = ModelDataCollector("IRIS", designation="predictions", feature_names=["SepalLengthCm","SepalWidthCm", "PetalLengthCm","PetalWidthCm","Predicted_Species"]) model_path = Model.get_model_path('IRIS') model = joblib.load(model_path+"/"+"iris_model.pkl") print('IRIS model loaded...')
def init(): global model, inputs_dc, prediction_dc, feature_names, categorical_features print("Model is initialized" + time.strftime("%H:%M:%S")) model_path = Model.get_model_path(model_name="driftmodel") model = joblib.load(model_path) feature_names = [ "usaf", "wban", "latitude", "longitude", "station_name", "p_k", "sine_weekofyear", "cosine_weekofyear", "sine_hourofday", "cosine_hourofday", "temperature-7" ] categorical_features = ["usaf", "wban", "p_k", "station_name"] inputs_dc = ModelDataCollector(model_name="driftmodel", identifier="inputs", feature_names=feature_names) prediction_dc = ModelDataCollector("driftmodel", identifier="predictions", feature_names=["temperature"])
def init(): try: # One-time initialization of PySpark and predictive model global trainedModel global spark global inputs_dc, prediction_dc model_name = "{model_name}" # interpolated inputs_dc = ModelDataCollector(model_name, identifier="inputs", feature_names=["json_input_data"]) prediction_dc = ModelDataCollector(model_name, identifier="predictions", feature_names=["predictions"]) spark = pyspark.sql.SparkSession.builder.appName( "AML Production Model").getOrCreate() model_path = Model.get_model_path(model_name) trainedModel = PipelineModel.load(model_path) except Exception as e: trainedModel = e
def init(): global logger global model global pred_collector global blob_service init_logger() pred_collector = ModelDataCollector(MODEL_NAME, identifier="imgpred", feature_names=["detection"]) model = load_model() blob_service = BlockBlobService(IMAGE_STORAGE_ACCOUNT_NAME, IMAGE_STORAGE_ACCOUNT_KEY) blob_service.create_container( IMAGE_STORAGE_CONTAINER_NAME) #fail_on_exist=False by default
def init(): global model global inputs_dc, prediction_dc global tokenizer global maxlen try: data_url = ('https://quickstartsws9073123377.blob.core.windows.net/' 'azureml-blobstore-0d1c4218-a5f9-418b-bf55-902b65277b85/' 'quickstarts/connected-car-data/connected-car_components.csv') # Load the car components labeled data car_components_df = pd.read_csv(data_url) components = car_components_df["text"].tolist() labels = car_components_df["label"].tolist() maxlen = 100 max_words = 10000 tokenizer = Tokenizer(num_words=max_words) tokenizer.fit_on_texts(components) model_name = 'MODEL-NAME' # Placeholder model name print('Looking for model path for model: ', model_name) model_path = Model.get_model_path(model_name = model_name) print('Loading model from: ', model_path) # Load the ONNX model model = onnxruntime.InferenceSession(model_path) print('Model loaded...') inputs_dc = ModelDataCollector("model_telemetry", designation="inputs") prediction_dc = ModelDataCollector("model_telemetry", designation="predictions", feature_names=["prediction"]) except Exception as e: print(e)
def init(): from azureml.monitoring import ModelDataCollector global model global inputs_dc, prediction_dc # Retreive path to model folder model_path = os.path.join(os.getenv("AZUREML_MODEL_DIR"), "model.pkl") # Deserialize the model file back into a sklearn model model = joblib.load(model_path) # Initialize data collectors inputs_dc = ModelDataCollector( model_name="cardiovascular_disease_model", designation="inputs", feature_names=[ "age", "gender", "systolic", "diastolic", "height", "weight", "cholesterol", "glucose", "smoker", "alcoholic", "active", "datetime", ], ) prediction_dc = ModelDataCollector( model_name="cardiovascular_disease_model", designation="predictions", feature_names=["cardiovascular_disease"], )
def init(): global model global inputs_dc inputs_dc = ModelDataCollector('elevation-regression-model.pkl', designation='inputs', feature_names=[ 'latitude', 'longitude', 'temperature', 'windAngle', 'windSpeed' ]) # note here "elevation-regression-model.pkl" is the name of the model registered under # this is a different behavior than before when the code is run locally, even though the code is the same. # AZUREML_MODEL_DIR is an environment variable created during deployment. # It is the path to the model folder (./azureml-models/$MODEL_NAME/$VERSION) # For multiple models, it points to the folder containing all deployed models (./azureml-models) model_path = os.path.join(os.getenv('AZUREML_MODEL_DIR'), 'elevation-regression-model.pkl') model = joblib.load(model_path)
def init(): global heart_disease_model global deploy_parameters global explainer_model global inputs_dc deploy_parameters = joblib.load("dependencies/deploy_parameters.pkl") model_path = Model.get_model_path( model_name=deploy_parameters.get("model_name")) heart_disease_model = joblib.load(model_path) explainer_model_path = Model.get_model_path( model_name=deploy_parameters.get("explainer_model_name")) explainer_model = joblib.load(explainer_model_path) inputs_dc = ModelDataCollector(deploy_parameters.get("model_name"), designation='inputs', feature_names=deploy_parameters.get("dataset_columns"))
def init(): global model global prediction_dc global storage_location storage_location = "/tmp/output" if not os.path.exists(storage_location): os.makedirs(storage_location) # next, we delete previous output files files = glob.glob(os.path.join(storage_location,'*')) for f in files: os.remove(f) model_path = Model.get_model_path(model_name = model_name) # deserialize the model file back into a sklearn model model = joblib.load(model_path) prediction_dc = ModelDataCollector("automl_model", identifier="predictions", feature_names=["prediction"])
# next, we delete previous output files files = glob.glob(os.path.join(storage_location,'*')) for f in files: os.remove(f) <<<<<<< HEAD model_name = "model.pkl" ======= >>>>>>> d07f34a81d6ad3c2bacb7beab8698c05dda9da19 model_path = Model.get_model_path(model_name = model_name) # deserialize the model file back into a sklearn model model = joblib.load(model_path) prediction_dc = ModelDataCollector("automl_model", identifier="predictions", feature_names=["prediction"]) def run(rawdata, window=14 * 24): """ :param data: :param window: :return: """ # set some parameters for the AD algorithm alpha = 0.1 max_anoms = 0.05 only_last = None # alternative, we can set this to 'hr' or 'day'