def saved_tf_iris_model(tmpdir): # Following code from # https://github.com/tensorflow/models/blob/master/samples/core/get_started/premade_estimator.py train_x, train_y = iris_data_utils.load_data()[0] # Feature columns describe how to use the input. my_feature_columns = [] for key in train_x.keys(): my_feature_columns.append(tf.feature_column.numeric_column(key=key)) # Build 2 hidden layer DNN with 10, 10 units respectively. estimator = tf.estimator.DNNClassifier( feature_columns=my_feature_columns, # Two hidden layers of 10 nodes each. hidden_units=[10, 10], # The model must choose between 3 classes. n_classes=3, ) # Train the Model. batch_size = 100 train_steps = 1000 estimator.train( input_fn=lambda: iris_data_utils.train_input_fn( train_x, train_y, batch_size), steps=train_steps, ) # Generate predictions from the model predict_x = { "SepalLength": [5.1, 5.9, 6.9], "SepalWidth": [3.3, 3.0, 3.1], "PetalLength": [1.7, 4.2, 5.4], "PetalWidth": [0.5, 1.5, 2.1], } estimator_preds = estimator.predict( lambda: iris_data_utils.eval_input_fn(predict_x, None, batch_size)) # Building a dictionary of the predictions by the estimator. if sys.version_info < (3, 0): estimator_preds_dict = estimator_preds.next() else: estimator_preds_dict = next(estimator_preds) for row in estimator_preds: for key in row.keys(): estimator_preds_dict[key] = np.vstack( (estimator_preds_dict[key], row[key])) # Building a pandas DataFrame out of the prediction dictionary. estimator_preds_df = copy.deepcopy(estimator_preds_dict) for col in estimator_preds_df.keys(): if all(len(element) == 1 for element in estimator_preds_df[col]): estimator_preds_df[col] = estimator_preds_df[col].ravel() else: estimator_preds_df[col] = estimator_preds_df[col].tolist() # Building a DataFrame that contains the names of the flowers predicted. estimator_preds_df = pandas.DataFrame.from_dict(data=estimator_preds_df) estimator_preds_results = [ iris_data_utils.SPECIES[id[0]] for id in estimator_preds_dict["class_ids"] ] estimator_preds_results_df = pd.DataFrame( {"predictions": estimator_preds_results}) # Define a function for estimator inference feature_spec = {} for name in my_feature_columns: feature_spec[name.key] = tf.Variable([], dtype=tf.float64, name=name.key) receiver_fn = tf.estimator.export.build_raw_serving_input_receiver_fn( feature_spec) # Save the estimator and its inference function saved_estimator_path = str(tmpdir.mkdir("saved_model")) saved_estimator_path = estimator.export_saved_model( saved_estimator_path, receiver_fn).decode("utf-8") return SavedModelInfo( path=saved_estimator_path, meta_graph_tags=["serve"], signature_def_key="predict", inference_df=pd.DataFrame( data=predict_x, columns=[name.key for name in my_feature_columns]), expected_results_df=estimator_preds_results_df, raw_results=estimator_preds_dict, raw_df=estimator_preds_df, )
def saved_tf_categorical_model(tmpdir): path = os.path.abspath("tests/data/uci-autos-imports-85.data") # Order is important for the csv-readers, so we use an OrderedDict here defaults = collections.OrderedDict([("body-style", [""]), ("curb-weight", [0.0]), ("highway-mpg", [0.0]), ("price", [0.0])]) types = collections.OrderedDict( (key, type(value[0])) for key, value in defaults.items()) df = pd.read_csv(path, names=list(types.keys()), dtype=types, na_values="?") df = df.dropna() # Extract the label from the features dataframe y_train = df.pop("price") # Create the required input training function trainingFeatures = {} for i in df: trainingFeatures[i] = df[i].values # Create the feature columns required for the DNNRegressor body_style_vocab = [ "hardtop", "wagon", "sedan", "hatchback", "convertible" ] body_style = tf.feature_column.categorical_column_with_vocabulary_list( key="body-style", vocabulary_list=body_style_vocab) feature_columns = [ tf.feature_column.numeric_column(key="curb-weight"), tf.feature_column.numeric_column(key="highway-mpg"), # Since this is a DNN model, convert categorical columns from sparse to dense. # Then, wrap them in an `indicator_column` to create a one-hot vector from the input tf.feature_column.indicator_column(body_style), ] # Build a DNNRegressor, with 20x20-unit hidden layers, with the feature columns # defined above as input estimator = tf.estimator.DNNRegressor(hidden_units=[20, 20], feature_columns=feature_columns) # Train the estimator and obtain expected predictions on the training dataset estimator.train(input_fn=lambda: iris_data_utils.train_input_fn( trainingFeatures, y_train, 1), steps=10) estimator_preds = np.array([ s["predictions"] for s in estimator.predict( lambda: iris_data_utils.eval_input_fn(trainingFeatures, None, 1)) ]).ravel() estimator_preds_df = pd.DataFrame({"predictions": estimator_preds}) # Define a function for estimator inference feature_spec = { "body-style": tf.Variable([], dtype=tf.string, name="body-style"), "curb-weight": tf.Variable([], dtype=tf.float64, name="curb-weight"), "highway-mpg": tf.Variable([], dtype=tf.float64, name="highway-mpg"), } receiver_fn = tf.estimator.export.build_raw_serving_input_receiver_fn( feature_spec) # Save the estimator and its inference function saved_estimator_path = str(tmpdir.mkdir("saved_model")) saved_estimator_path = estimator.export_saved_model( saved_estimator_path, receiver_fn).decode("utf-8") return SavedModelInfo( path=saved_estimator_path, meta_graph_tags=["serve"], signature_def_key="predict", inference_df=trainingFeatures, expected_results_df=estimator_preds_df, raw_results=None, raw_df=None, )