Command Line Interface (CLI) tools used to manage 3Blades resources. CLI tools connect to 3Blades backend API.
Review our online documentation for a full list of available command options.
Install Go as instructed here https://golang.org/doc/install. Although described in the installation instructions, the basic steps to set up Go are described below.
Although not obligatory, its a good idea to set your GOPATH working directory:
mkdir $HOME/go
GOPATH=$HOME/go
Make sure you have go available in your shell.
go version
If you don't see any output, make sure your path reflects:
PATH=$PATH:/usr/local/go/bin
Get all you need and compile:
go get github.com/3Blades/cli-tools/tbs
If you added your bin folder from GOPATH to your PATH then you can just run:
tbs
If don't then:
cd $GOPATH/bin
./tbs
If you have no error message then you are good to go :)
If you want to recompile from local source then:
cd $GOPATH/src/github.com/3Blades/cli-tools/tbs
go install
To update cli-tools you can do:
go get -u github.com/3Blades/cli-tools/tbs
In order for cli-tools to work with 3Blades API server you need to put your api endpoint to config file. CLI are looking for config file in your home directory. Default config file can be json, yaml or toml for example
$HOME/.threeblades.yaml
Currently supported options are:
root: http://localhost:5000 // api root
An example will use tensorflow and keras for modelling.
Note 1: You need to set your apidomain or if you do local development to your machine IP here:
http://localhost:5000/admin/sites/site/ It needs to be set with port.
For me it is 192.168.0.100:5000
.
Note 2: You will need your api token in order to make requests to model server. After you login to api with this cli tools, you can find your token inside a file $HOME/.threeblades.token
.
Create notebook:
tbs server create --name keras_cpu --image keras --type jupyter
Start notebook:
tbs server start --name keras_cpu
Go to http://localhost:5000/server/<notebook_id>/jupyter/tree
.
We will use this dataset.
Download it and save as pima-indians-diabetes.csv
. You can upload it to notebook with notebook ui on notebook home page.
We will create our model now:
from keras.models import Sequential
from keras.layers import Dense
import numpy
import os
# fix random seed for reproducibility
numpy.random.seed(7)
# split into input (X) and output (Y) variables
X = dataset[:,0:8]
Y = dataset[:,8]
# create model
model = Sequential()
model.add(Dense(12, input_dim=8, kernel_initializer='uniform', activation='relu'))
model.add(Dense(8, kernel_initializer='uniform', activation='relu'))
model.add(Dense(1, kernel_initializer='uniform', activation='sigmoid'))
# Compile model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Fit the model
model.fit(X, Y, epochs=150, batch_size=10, verbose=0)
# evaluate the model
scores = model.evaluate(X, Y, verbose=0)
print("%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
# serialize model to JSON
model_json = model.to_json()
with open("model.json", "w") as json_file:
json_file.write(model_json)
print("Saved model to disk")
In order to use our new saved model as restful endpoint we need to create a script that will load our model and process data.
In notebook create a file called model.py
and paste following code:
import json
import numpy
from keras.models import model_from_json
def load_model():
with open('model.json', 'r') as json_file:
loaded_model_json = json_file.read()
loaded_model = model_from_json(loaded_model_json)
return loaded_model
def main(json_data):
"""
Example json_data:
{
"X": [[6,148,72,35,0,33.6,0.627,50], [1,85,66,29,0,26.6,0.351,31]]
}
"""
data = json.loads(json_data)
model = load_model()
X = numpy.asarray(data["X"])
predictions = model.predict(X)
return json.dumps(predictions.tolist())
Save the file.
Go to console and create a model server:
tbs server create --name keras_model --image keras --resources <resources_uuid> --type restful --script model.py --function main
Start your model server:
tbs server start --name keras_model
Send a request to your new model server:
curl -X POST -d '{"schema_version": "0.1", "model_version":"1.0", "timestamp":"2017-04-04T17:43:45.022569696Z", "data": {"X": [[6,148,72,35,0,33.6,0.627,50], [1,85,66,29,0,26.6,0.351,31]]}}' -H "Authorization: Token <your_token>" http://localhost:5000/server/<server_uuid>/restful/
You should get a response similar to this:
{"schema_version":"0.1","model_version":"1.0","timestamp":"2017-04-05T13:09:00.052713946Z","status":"ok","execution_time":62,"data":[[0.5022257566452026],[0.5014487504959106]]}
In order to connect to your own node you need to install there docker engine and set it up to listen on a port. After that you need run command:
tbs host create --name HostName --ip "<your_host_ip>" --port 2375
Then you will be able to run your servers on your own node.
To stream server logs please use this command:
tbs server logs --name <server_name>
Ctrl-C to interrupt stream.