def execute(self, function_context: FunctionContext, input_list: List) -> List: model_name = function_context.node_spec.model.name validated_model = af.get_latest_validated_model_version(model_name) # Deprecate deployed model deployed_model_version = af.get_deployed_model_version(model_name) if deployed_model_version is not None: af.update_model_version( model_name=model_name, model_version=deployed_model_version.version, current_stage=ModelVersionStage.DEPRECATED) af.update_model_version(model_name=model_name, model_version=validated_model.version, current_stage=ModelVersionStage.DEPLOYED) deployed_model_version = af.get_deployed_model_version( model_name=model_name) # Copy deployed model to deploy_model_dir deployed_model_dir = af.get_artifact_by_name(self.artifact).stream_uri if not os.path.exists(deployed_model_dir): os.makedirs(deployed_model_dir) for file in os.listdir(deployed_model_dir): file_path = os.path.join(deployed_model_dir, file) if os.path.isfile(file_path): os.remove(file_path) elif os.path.isdir(file_path): shutil.rmtree(file_path, True) shutil.copy(deployed_model_version.model_path, deployed_model_dir) return []
def execute(self, function_context: FunctionContext, input_list: List) -> List: deployed_model_version = af.get_deployed_model_version(model_name=self.model_name) if deployed_model_version is None: af.update_model_version(model_name=self.model_name, model_version=self.model_version, current_stage=ModelVersionStage.VALIDATED) else: x_validate, y_validate = input_list[0][0], input_list[0][1] clf = load(self.model_path) scores = cross_val_score(clf, x_validate, y_validate, scoring='precision_macro', cv=5) deployed_clf = load(deployed_model_version.model_path) deployed_scores = cross_val_score(deployed_clf, x_validate, y_validate, scoring='precision_macro') batch_uri = af.get_artifact_by_name(self.artifact).batch_uri if np.mean(scores) > np.mean(deployed_scores): af.update_model_version(model_name=self.model_name, model_version=self.model_version, current_stage=ModelVersionStage.VALIDATED) with open(batch_uri, 'a') as f: f.write('deployed model version[{}] scores: {}\n'.format(deployed_model_version.version, deployed_scores)) f.write('generated model version[{}] scores: {}\n'.format(self.model_version, scores)) return []
def process(self, execution_context: ExecutionContext, input_list: List) -> List: model_meta: af.ModelMeta = execution_context.config.get('model_info') model_name = model_meta.name validated_model = af.get_latest_validated_model_version(model_name) cur_deployed_model = af.get_deployed_model_version( model_name=model_name) if cur_deployed_model is not None: af.update_model_version(model_name=model_name, model_version=cur_deployed_model.version, current_stage=ModelVersionStage.DEPRECATED) af.update_model_version(model_name=model_name, model_version=validated_model.version, current_stage=ModelVersionStage.DEPLOYED) # Copy deployed model to deploy_model_dir deployed_model_dir = af.get_artifact_by_name(self.artifact).uri if not os.path.exists(deployed_model_dir): os.makedirs(deployed_model_dir) for file in os.listdir(deployed_model_dir): file_path = os.path.join(deployed_model_dir, file) if os.path.isfile(file_path): os.remove(file_path) elif os.path.isdir(file_path): shutil.rmtree(file_path, True) shutil.copy(validated_model.model_path, deployed_model_dir) return []
def process(self, execution_context: ExecutionContext, input_list: List) -> List: model_meta: af.ModelMeta = execution_context.config.get('model_info') model_name = model_meta.name validated_model = af.get_latest_validated_model_version(model_name) # Deprecate deployed model deployed_model_version = af.get_deployed_model_version(model_name) if deployed_model_version is not None: af.update_model_version( model_name=model_name, model_version=deployed_model_version.version, current_stage=ModelVersionStage.DEPRECATED) af.update_model_version(model_name=model_name, model_version=validated_model.version, current_stage=ModelVersionStage.DEPLOYED) af.get_ai_flow_client().send_event( BaseEvent(key='START_PREDICTION', value=validated_model.version)) print(validated_model.version) # Copy deployed model to deploy_model_dir deployed_model_dir = af.get_artifact_by_name(self.artifact).uri if not os.path.exists(deployed_model_dir): os.makedirs(deployed_model_dir) for file in os.listdir(deployed_model_dir): file_path = os.path.join(deployed_model_dir, file) if os.path.isfile(file_path): os.remove(file_path) elif os.path.isdir(file_path): shutil.rmtree(file_path, True) deployed_model_version = af.get_deployed_model_version(model_name) shutil.copy(deployed_model_version.model_path, deployed_model_dir) return []
def execute(self, function_context: FunctionContext, input_list: List) -> List: model_meta: ModelMeta = function_context.node_spec.model serving_model_version = af.get_deployed_model_version(model_name=model_meta.name) if serving_model_version is None: af.update_model_version(model_name=model_meta.name, model_version=self.model_version, current_stage=ModelVersionStage.DEPLOYED) else: x_validate, y_validate = input_list[0][0], input_list[0][1] scoring = ['precision_macro', 'recall_macro'] serving_clf = load(serving_model_version.model_path) serving_scores = cross_validate(serving_clf, x_validate, y_validate, scoring=scoring) clf = load(self.model_path) scores = cross_validate(clf, x_validate, y_validate, scoring=scoring) batch_uri = af.get_artifact_by_name('validate_artifact').batch_uri with open(batch_uri, 'a') as f: f.write('serving model version[{}] scores: {}\n'.format(serving_model_version.version, serving_scores)) f.write('generated model version[{}] scores: {}\n'.format(self.model_version, scores)) if scores.mean() > serving_scores.mean(): af.update_model_version(model_name=model_meta.name, model_version=serving_model_version.version, current_stage=ModelVersionStage.VALIDATED) af.update_model_version(model_name=model_meta.name, model_version=self.model_version, current_stage=ModelVersionStage.DEPLOYED) return []
def execute(self, function_context: FunctionContext, input_list: List) -> List: x_evaluate, y_evaluate = input_list[0][0], input_list[0][1] clf = load(self.model_path) scores = cross_val_score(clf, x_evaluate, y_evaluate, cv=5) evaluate_artifact = af.get_artifact_by_name(self.artifact).batch_uri with open(evaluate_artifact, 'a') as f: f.write('model version[{}] scores: {}\n'.format(self.model_version, scores)) return []
def execute(self, function_context: FunctionContext, input_list: List) -> List: print("### {}".format(self.__class__.__name__)) x_evaluate, y_evaluate = input_list[0][0], input_list[0][1] clf = load(self.model_path) scores = cross_val_score(clf, x_evaluate, y_evaluate, cv=5) evaluate_artifact = af.get_artifact_by_name('evaluate_artifact2').stream_uri with open(evaluate_artifact, 'a') as f: f.write('model version[{}] scores: {}\n'.format(self.model_version, scores)) return []
def process(self, execution_context: ExecutionContext, input_list: List) -> List: """ Validate and deploy model if necessary """ current_model_meta: af.ModelMeta = execution_context.config.get( 'model_info') deployed_model_version = af.get_deployed_model_version( model_name=current_model_meta.name) new_model_meta = af.get_latest_generated_model_version( current_model_meta.name) uri = af.get_artifact_by_name(self.artifact).uri if deployed_model_version is None: # If there is no deployed model for now, update the current generated model to be deployed. af.update_model_version(model_name=current_model_meta.name, model_version=new_model_meta.version, current_stage=ModelVersionStage.VALIDATED) af.update_model_version(model_name=current_model_meta.name, model_version=new_model_meta.version, current_stage=ModelVersionStage.DEPLOYED) else: x_validate = input_list[0][0] y_validate = input_list[0][1] knn = load(new_model_meta.model_path) scores = knn.score(x_validate, y_validate) deployed_knn = load(deployed_model_version.model_path) deployed_scores = deployed_knn.score(x_validate, y_validate) with open(uri, 'a') as f: f.write('deployed model version: {} scores: {}\n'.format( deployed_model_version.version, deployed_scores)) f.write('generated model version: {} scores: {}\n'.format( new_model_meta.version, scores)) if scores >= deployed_scores: # Deprecate current model and deploy better new model af.update_model_version( model_name=current_model_meta.name, model_version=deployed_model_version.version, current_stage=ModelVersionStage.DEPRECATED) af.update_model_version( model_name=current_model_meta.name, model_version=new_model_meta.version, current_stage=ModelVersionStage.VALIDATED) af.update_model_version( model_name=current_model_meta.name, model_version=new_model_meta.version, current_stage=ModelVersionStage.DEPLOYED) return []
def execute(self, function_context: FunctionContext, input_list: List) -> List: node_spec = function_context.node_spec serving_model_path = af.get_artifact_by_name('push_model_artifact').batch_uri if not os.path.exists(serving_model_path): os.makedirs(serving_model_path) serving_model_version = None if serving_model_version is None: serving_model_version = af.get_deployed_model_version(model_name=node_spec.model.name) for file in os.listdir(serving_model_path): file_path = os.path.join(serving_model_path, file) if os.path.isfile(file_path): os.remove(file_path) elif os.path.isdir(file_path): shutil.rmtree(file_path, True) shutil.copy(serving_model_version.model_path, serving_model_path) return []
def execute(self, function_context: FunctionContext, input_list: List) -> List: deployed_model_version = af.get_deployed_model_version( model_name=self.model_name) x_validate, y_validate = input_list[0][0], input_list[0][1] clf = load(self.model_path) scores = cross_val_score(clf, x_validate, y_validate, scoring='precision_macro') stream_uri = af.get_artifact_by_name(self.artifact_name).stream_uri if deployed_model_version is None: with open(stream_uri, 'a') as f: f.write('generated model version[{}] scores: {}\n'.format( self.model_version, np.mean(scores))) af.update_model_version(model_name=self.model_name, model_version=self.model_version, current_stage=ModelVersionStage.VALIDATED) else: deployed_clf = load(deployed_model_version.model_path) deployed_scores = cross_val_score(deployed_clf, x_validate, y_validate, scoring='precision_macro') f = open(stream_uri, 'a') f.write('current model version[{}] scores: {}\n'.format( deployed_model_version.version, np.mean(deployed_scores))) f.write('new generated model version[{}] scores: {}\n'.format( self.model_version, np.mean(scores))) if np.mean(scores) > np.mean(deployed_scores): # Make latest generated model to be validated af.update_model_version( model_name=self.model_name, model_version=self.model_version, current_stage=ModelVersionStage.VALIDATED) f.write('new generated model version[{}] pass validation.\n'. format(self.model_version)) else: f.write('new generated model version[{}] fail validation.\n'. format(self.model_version)) f.close() return []
def execute(self, function_context: FunctionContext, input_list: List) -> List: model_artifact = af.get_artifact_by_name('push_model_artifact').batch_uri clf = load(os.path.join(model_artifact, os.listdir(model_artifact)[0])) return [clf.predict(input_list[0][0])]