Our models expect to receive very specific data fields that have restrictions on the data types. To ensure data being consumed by the model is valid, we will associate data schemas for the input data and for the data produced by the model.

Let's view the data schemas that our models need!

fastscore schema show gbm_input

This schema contains a list if specific attributes that the model expects in order to produce a score.

Similarly, the output data is designed to have a specific structure. Let's look at the output schema:

fastscore schema show gbm_output

Since the model is just producing one number, a double, between -3 and 3, this schema is pretty simple.

It is best practice to separate the model from how the data will be transported in and out of the model.

Let's take a look at the different transports that will used in this scenario!

In the testing phase, a static file may be used to ensure the models execute properly in FastScore.

Let's look at the first row of data this model will consume (this example file only contains 5 rows of data):

head -1 ./katacoda/fastscore-intro/data/input_data.jsons

If the data structure does not match the input schema, we will receive an error. This ensures that the data structure expectations are met at all times.

Let's look at the data transport to feed data into the model from the file:

fastscore stream show file_in

The data transports specify where the data is located, how to move the data, and how the data is encoded.

This scenario will also switch the model from batch scoring to streaming by changing the data transports from a file to using Kafka (used for building real-time data pipelines). Let's look at the kafka transport:

fastscore stream show kafka_in

FastScore requires at least one model and an associated schema for every data transport. In this scenario, we will deploy our model with one input data transport and one output data transport. Each model is deployed in its own FastScore Engine. When we set up FastScore, we initialized 4 FastScore Engines. Let's deploy our python model in engine 1!

fastscore use engine-1

fastscore model load gbm_python

The engine is now waiting for data transports to send data so that it can produce scores. FastScore supports multiple input and output data transports, but we will be only using one of each. Let's set the transports!

We will be sending the data through a file and writing the scores to an output file:

fastscore stream attach file_in 0

The 0 here is the index of the Engine input slot we are using. See this documentation for more information on multiple input and output slots.

Let's set our output data stream:

fastscore stream attach file_out 1

Now, let's see the scores from the model:

head -5 ./katacoda/fastscore-intro/data/output_data.jsons

Let's reset the same engine and attach the kafka data transport to turn it into a streaming model! We will also produce the score and send them over kafka.

fastscore engine reset

fastscore model load gbm_python

fastscore stream attach kafka_in 0

fastscore stream attach kafka_out 1

We are going to use a utility called kafkaesq that will send data row by row from a specified file over a kafka topic that we will use as the input of the model. This utility will also receive data over the output topic and write the data to the console. Let's score the python model! We will specify the file location, the input topic name, and the output topic name (cleverly named "input" and "output").

./kafkaesq --input-file data/input_data.jsons input output