# Online IDE ? – do it yourself

Jupyter Notebook is one of the most useful tool for data exploration, machine learning and fast prototyping. There are many plugins and projects which make it even more powerful:
* jupyterlab-git
* nbdev
* jupyter debugger

But sometimes you simply need IDE …

One of my favorite text editor is vim. It is lightweight, fast and with appropriate plugins it can be used as a IDE.
Using Dockerfile you can build jupyter environment with fully equipped vim:

FROM continuumio/miniconda3
RUN apt update && apt install curl git cmake ack g++ python3-dev vim-youcompleteme tmux -yq
RUN sh -c "$(curl -fsSL https://raw.githubusercontent.com/qooba/vim-python-ide/master/setup.sh)" RUN conda install xeus-python jupyterlab jupyterlab-git -c conda-forge RUN jupyter labextension install @jupyterlab/debugger @jupyterlab/git RUN pip install nbdev RUN echo "alias ls='ls --color=auto'" >> /root/.bashrc CMD bin/bash  Now you can run the image: docker run --name jupyter -d --rm -p 8888:8888 -v$(pwd)/jupyter:/root/.jupyter -v $(pwd)/notebooks:/opt/notebooks qooba/miniconda3 /bin/bash -c "jupyter lab --notebook-dir=/opt/notebooks --ip='0.0.0.0' --port=8888 --no-browser --allow-root --NotebookApp.password='' --NotebookApp.token=''"  In the jupyter lab start terminal session, run bash (it works better in bash) and then vim. The online IDE is ready: # References [1] Top image Boskampi from Pixabay # FastAI with TensorRT on Jetson Nano IoT and AI are the hottest topics nowadays which can meet on Jetson Nano device. In this article I’d like to show how to use FastAI library, which is built on the top of the PyTorch on Jetson Nano. Additionally I will show how to optimize the FastAI model for the usage with TensorRT. You can find the code on https://github.com/qooba/fastai-tensorrt-jetson.git. # 1. Training Although the Jetson Nano is equipped with the GPU it should be used as a inference device rather than for training purposes. Thus I will use another PC with the GTX 1050 Ti for the training. Docker gives flexibility when you want to try different libraries thus I will use the image which contains the complete environment. Training environment Dockerfile: FROM nvcr.io/nvidia/tensorrt:20.01-py3 WORKDIR / RUN apt-get update && apt-get -yq install python3-pil RUN pip3 install jupyterlab torch torchvision RUN pip3 install fastai RUN DEBIAN_FRONTEND=noninteractive && apt update && apt install curl git cmake ack g++ tmux -yq RUN pip3 install ipywidgets && jupyter nbextension enable --py widgetsnbextension CMD ["sh","-c", "jupyter lab --notebook-dir=/opt/notebooks --ip='0.0.0.0' --port=8888 --no-browser --allow-root --NotebookApp.password='' --NotebookApp.token=''"]  To use GPU additional nvidia drivers (included in the NVIDIA CUDA Toolkit) are needed. If you don’t want to build your image simply run: docker run --gpus all --name jupyter -d --rm -p 8888:8888 -v$(pwd)/docker/gpu/notebooks:/opt/notebooks qooba/fastai:1.0.60-gpu


Now you can use pets.ipynb notebook (the code is taken from lesson 1 FastAI course) to train and export pets classification model.

from fastai.vision import *
from fastai.metrics import error_rate

path = untar_data(URLs.PETS)
path_anno = path/'annotations'
path_img = path/'images'
fnames = get_image_files(path_img)

# prepare data
np.random.seed(2)
pat = r'/([^/]+)_\d+.jpg$' bs = 16 data = ImageDataBunch.from_name_re(path_img, fnames, pat, ds_tfms=get_transforms(), size=224, bs=bs).normalize(imagenet_stats) # prepare model learner learn = cnn_learner(data, models.resnet34, metrics=error_rate) # train learn.fit_one_cycle(4) # export learn.export('/opt/notebooks/export.pkl')  Finally you get pickled pets model (export.pkl). # 2. Inference (Jetson Nano) The Jetson Nano device with Jetson Nano Developer Kit already comes with the docker thus I will use it to setup the inference environment. I have used the base image nvcr.io/nvidia/l4t-base:r32.2.1 and installed the pytorch and torchvision. If you have JetPack 4.4 Developer Preview you can skip this steps and start with the base image nvcr.io/nvidia/l4t-pytorch:r32.4.2-pth1.5-py3. The FastAI installation on Jetson is more problematic because of the blis package. Finally I have found the solution here. Additionally I have installed torch2trt package which converts PyTorch model to TensorRT. Finally I have used the tensorrt from the JetPack which can be found in /usr/lib/python3.6/dist-packages/tensorrt . The final Dockerfile is: FROM nvcr.io/nvidia/l4t-base:r32.2.1 WORKDIR / # install pytorch RUN apt update && apt install -y --fix-missing make g++ python3-pip libopenblas-base RUN wget https://nvidia.box.com/shared/static/ncgzus5o23uck9i5oth2n8n06k340l6k.whl -O torch-1.4.0-cp36-cp36m-linux_aarch64.whl RUN pip3 install Cython RUN pip3 install numpy torch-1.4.0-cp36-cp36m-linux_aarch64.whl # install torchvision RUN apt update && apt install libjpeg-dev zlib1g-dev git libopenmpi-dev openmpi-bin -yq RUN git clone --branch v0.5.0 https://github.com/pytorch/vision torchvision RUN cd torchvision && python3 setup.py install # install fastai RUN pip3 install jupyterlab ENV TZ=Europe/Warsaw RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone && apt update && apt -yq install npm nodejs python3-pil python3-opencv RUN apt update && apt -yq install python3-matplotlib RUN git clone https://github.com/NVIDIA-AI-IOT/torch2trt.git /torch2trt && mv /torch2trt/torch2trt /usr/local/lib/python3.6/dist-packages && rm -r /torch2trt COPY tensorrt /usr/lib/python3.6/dist-packages/tensorrt RUN pip3 install --no-deps fastai RUN git clone https://github.com/fastai/fastai /fastai RUN apt update && apt install libblas3 liblapack3 liblapack-dev libblas-dev gfortran -yq RUN curl -LO https://github.com/explosion/cython-blis/files/3566013/blis-0.4.0-cp36-cp36m-linux_aarch64.whl.zip && unzip blis-0.4.0-cp36-cp36m-linux_aarch64.whl.zip && rm blis-0.4.0-cp36-cp36m-linux_aarch64.whl.zip COPY blis-0.4.0-cp36-cp36m-linux_aarch64.whl . RUN pip3 install scipy pandas blis-0.4.0-cp36-cp36m-linux_aarch64.whl spacy fastai scikit-learn CMD ["sh","-c", "jupyter lab --notebook-dir=/opt/notebooks --ip='0.0.0.0' --port=8888 --no-browser --allow-root --NotebookApp.password='' --NotebookApp.token=''"]  As before you can skip the docker image build and use ready image: docker run --runtime nvidia --network app_default --name jupyter -d --rm -p 8888:8888 -e DISPLAY=$DISPLAY -v /tmp/.X11-unix/:/tmp/.X11-unix -v $(pwd)/docker/jetson/notebooks:/opt/notebooks qooba/fastai:1.0.60-jetson  Now we can open jupyter notebook on jetson and move pickled model file export.pkl from PC. The notebook jetson_pets.ipynb show how to load the model. import torch from torch2trt import torch2trt from fastai.vision import * from fastai.metrics import error_rate learn = load_learner('/opt/notebooks/') learn.model.eval() model=learn.model if torch.cuda.is_available(): input_batch = input_batch.to('cuda') model.to('cuda')  Additionally we can optimize the model using torch2trt package: x = torch.ones((1, 3, 224, 224)).cuda() model_trt = torch2trt(learn.model, [x])  Let’s prepare example input data: import urllib url, filename = ("https://github.com/pytorch/hub/raw/master/dog.jpg", "dog.jpg") try: urllib.URLopener().retrieve(url, filename) except: urllib.request.urlretrieve(url, filename) from PIL import Image from torchvision import transforms input_image = Image.open(filename) preprocess = transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]), ]) input_tensor = preprocess(input_image) input_batch = input_tensor.unsqueeze(0)  Finally we can run prediction for PyTorch and TensorRT model: x=input_batch y = model(x) y_trt = model_trt(x)  and compare PyTorch and TensorRT performance: def prediction_time(model, x): import time times = [] for i in range(20): start_time = time.time() y_trt = model(x) delta = (time.time() - start_time) times.append(delta) mean_delta = np.array(times).mean() fps = 1/mean_delta print('average(sec):{},fps:{}'.format(mean_delta,fps)) prediction_time(model,x) prediction_time(model_trt,x)  where for: * PyTorch – average(sec):0.0446, fps:22.401 * TensorRT – average(sec):0.0094, fps:106.780 The TensorRT model is almost 5 times faster thus it is worth to use torch2trt. # References [1] Top image DrZoltan from Pixabay # Azuronet – Warsaw .NET & Azure Meetup #2 With big pleasure I would like to invite you to join Azuronet – .NET & Azure Meetup #2 in Warsaw, where I will talk (in polish) about Milla project and give you some insights into the world of chatbots and intelligent assistants. # Live and let her speak – congratulations for the Milla chatbot I am pleased to hear that the first Polish banking chatbot with which you can make a transfer was awarded in a competition organized by a Gazeta Bankowa. With Milla you can talk in the Bank Millennium mobile application. Currently, Milla can speak (text to speech), listen (automatic speak recognition) and understand what you write to her (intent detection with slot filling). This is not a sponsored post 🙂 but I’ve been developing Milla for the few months and I’m really happy that I had opportunity to do this. Have a nice talk with Milla. # Quantum teleportation do it yourself with Q# Quantum computing nowadays is the one of the hottest topics in the computer science world. Recently IBM unveiled the IBM Q System One: a 20-qubit quantum computer which is touting as “the world’s first fully integrated universal quantum computing system designed for scientific and commercial use”. In this article I’d like how to show the quantum teleportation phenomenon. I will use the Q# language designed by Microsoft to simplify creating quantum algorithms. In this example I have used the quantum simulator which I have wrapped with the REST api and put into the docker image. Quantum teleportation allows moving a quantum state from one location to another. Shared quantum entanglement between two particles in the sending and receiving locations is used to do this without having to move physical particles along with it. # 1. Theory Let’s assume that we want to send the message, specific quantum state described using Dirac notation: $$|\psi\rangle=\alpha|0\rangle+\beta|1\rangle$$ Additionally we have two entangled qubits, first in Laboratory 1 and second in Laboratory 2: $$|\phi^+\rangle=\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle)$$ thus we starting with the input state: $$|\psi\rangle|\phi^+\rangle=(\alpha|0\rangle+\beta|1\rangle)(\frac{1}{\sqrt{2}}(|00\rangle+|11\rangle))$$ $$|\psi\rangle|\phi^+\rangle=\frac{\alpha}{\sqrt{2}}|000\rangle + \frac{\alpha}{\sqrt{2}}|011\rangle + \frac{\beta}{\sqrt{2}}|100\rangle + \frac{\beta}{\sqrt{2}}|111\rangle$$ To send the message we need to start with two operations applying CNOT and then Hadamard gate. CNOT gate flips the second qubit only if the first qubit is 1. Applying CNOT gate will modify the first qubit of the input state and will result in: $$\frac{\alpha}{\sqrt{2}}|000\rangle + \frac{\alpha}{\sqrt{2}}|011\rangle + \frac{\beta}{\sqrt{2}}|110\rangle + \frac{\beta}{\sqrt{2}}|101\rangle$$ Hadamard gate changes states as follows: $$|0\rangle \rightarrow \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle))$$ and $$|1\rangle \rightarrow \frac{1}{\sqrt{2}}(|0\rangle-|1\rangle))$$ Applying Hadmard gate results in: $$\frac{\alpha}{\sqrt{2}}(\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle))|00\rangle + \frac{\alpha}{\sqrt{2}}(\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle))|11\rangle + \frac{\beta}{\sqrt{2}}(\frac{1}{\sqrt{2}}(|0\rangle-|1\rangle))|10\rangle + \frac{\beta}{\sqrt{2}}(\frac{1}{\sqrt{2}}(|0\rangle-|1\rangle))|01\rangle$$ and: $$\frac{1}{2}(\alpha|000\rangle+\alpha|100\rangle+\alpha|011\rangle+\alpha|111\rangle+\beta|010\rangle-\beta|110\rangle+\beta|001\rangle-\beta|101\rangle)$$ which we can write as: $$\frac{1}{2}(|00\rangle(\alpha|0\rangle+\beta|1\rangle)+|01\rangle(\alpha|1\rangle+\beta|0\rangle)+|10\rangle(\alpha|0\rangle-\beta|1\rangle)+|11\rangle(\alpha|1\rangle-\beta|0\rangle))$$ Then we measure the states of the first two qubits (message qubit and Laboratory 1 qubit) where we can have four results: • $|00\rangle$ which simplifies equation to: $|00\rangle(\alpha|0\rangle+\beta|1\rangle)$ and indicates that the qubit in the Laboratory 2 is $\alpha|0\rangle+\beta|1\rangle$ • $|01\rangle$ which simplifies equation to: $|01\rangle(\alpha|1\rangle+\beta|0\rangle)$ and indicates that the qubit in the Laboratory 2 is $\alpha|1\rangle+\beta|0\rangle$ • $|10\rangle$ which simplifies equation to: $|10\rangle(\alpha|0\rangle-\beta|1\rangle)$ and indicates that the qubit in the Laboratory 2 is $\alpha|0\rangle-\beta|1\rangle$ • $|11\rangle$ which simplifies equation to: $|11\rangle(\alpha|1\rangle-\beta|0\rangle)$ and indicates that the qubit in the Laboratory 2 is $\alpha|1\rangle-\beta|0\rangle$ Now we have to send the result classical way from Laboratory 1 to Laboratory 2. Finally we know what transformation we need to apply to qubit in the Laboratory 2 to make its state equal to message qubit: $$|\psi\rangle=\alpha|0\rangle+\beta|1\rangle$$ if Laboratory 2 qubit is in state: • $\alpha|0\rangle+\beta|1\rangle$ we don’t need to do anything. • $\alpha|1\rangle+\beta|0\rangle$ we need to apply NOT gate. • $\alpha|0\rangle-\beta|1\rangle$ we need to apply Z gate. • $\alpha|1\rangle-\beta|0\rangle$ we need to apply NOT gate followed by Z gate This operations will transform Laboratory 2 qubit state to initial message qubit state thus we moved the particle state from Laboratory 1 to Laboratory 2 without moving particle. # 2. Code Now it’s time to show the quantum teleportation using Q# language. I have used Microsoft Quantum Development Kit to run the Q# code inside the .NET Core application. Additionally I have added the nginx proxy with the angular gui which will help to show the results. Everything was put inside the docker to simplify the setup. Before you will start you will need git, docker and docker-compose installed on your machine (https://docs.docker.com/get-started/) To run the project we have to clone the repository and run it using docker compose: git clone https://github.com/qooba/quantum-teleportation-qsharp.git cd quantum-teleportation-qsharp docker-compose -f app/docker-compose.yml up  Now we can run the http://localhost:8020/ in the browser: Then we can put the message in the Laboratory 1, click the Teleport button, trigger for the teleportation process which sends the message to the Laboratory 2. The text is converted into array of bits and each bit is sent to the Laboratory 2 using quantum teleportation. In the first step we encode the incoming message using X gate. if (message) { X(msg); }  Then we prepare the entanglement between the qubits in the Laboratory 1 and Laboratory 2. H(here); CNOT(here, there);  In the second step we apply CNOT and Hadamard gate to send the message: CNOT(msg, here); H(msg);  Finally we measure the message qubit and the Laboratory 1 qubit: if (M(msg) == One) { Z(there); } if (M(here) == One) { X(there); }  If the message qubit has state $|1\rangle$ then we need to apply the Z gate to the Laboratory 2 qubit. If the Laboratory 1 qubit has state $|1\rangle$ then we need to apply the X gate to the Laboratory 2 qubit. This information must be sent classical way to the Laboratory 2. Now the Laboratory 2 qubit state is equal to the initial message qubit state and we can check it: if (M(there) == One) { set measurement = true; }  This kind of communication is secure because even if someone will take over the information sent classical way it is still impossible to decode the message. # Boosting Elasticsearch with machine learning – Elasticsearch, RankLib, Docker Elastic search is powerful search engine. Its distributed architecture give ability to build scalable full-text search solution. Additionally it provides comprehensive query language. Despite this sometimes the engine and search results is not enough to meet the expectations of users. In such situations it is possible to boost search quality using machine learning algorithms. In this article I will show how to do this using RankLib library and LambdaMart algorithm . Moreover I have created ready to use platform which: 1. Index the data 2. Helps to label the search results in the user friendly way 3. Trains the model 4. Deploys the model to elastic search 5. Helps to test the model The whole project is setup on the docker using docker compose thus you can setup it very easy. The platform is based on the elasticsearch learning to rank plugin. I have also used the python example described in this project. Before you will start you will need docker and docker-compose installed on your machine (https://docs.docker.com/get-started/) To run the project you have to clone it: git clone https://github.com/qooba/elasticsearch-learning-to-rank.git  Then to make elasticsearch working you need to create data folder with appropriate access: cd elasticsearch-learning-to-rank/ mkdir docker/elasticsearch/esdata1 chmod g+rwx docker/elasticsearch/esdata1 chgrp 1000 docker/elasticsearch/esdata1  Finally you can run the project: docker-compose -f app/docker-compose.yml up  Now you can open the http://localhost:8020/. # 1. Architecture There are three main components: A. The ngnix reverse proxy with angular app B. The flask python app which orchestrates the whole ML solution C. The elastic search with rank lib plugin installed ### A. Ngnix I have used the Ngnix reverse proxy to expose the flask api and the angular gui which helps with going through the whole proces. ngnix.config server { listen 80; server_name localhost; root /www/data; location / { autoindex on; } location /images/ { autoindex on; } location /js/ { autoindex on; } location /css/ { autoindex on; } location /training/ { proxy_set_header Host$host;
proxy_set_header   X-Real-IP            $remote_addr; proxy_set_header X-Forwarded-For$proxy_add_x_forwarded_for;
proxy_set_header   X-Forwarded-Proto    $scheme; proxy_set_header Host$http_host;

proxy_pass http://training-app:5090;
}
}


This is the core of the project. It exposes api for:

• Indexing
• Labeling
• Training
• Testing

It calls directly the elastic search to get the data and do the modifications.
Because training with RankLib require the java thus Docker file for this part contains default-jre installation. Additionally it downloads the RankLib-2.8.jar and tmdb.json (which is used as a default data source) from: http://es-learn-to-rank.labs.o19s.com/.

Dockerfile

FROM python:3

RUN \
apt update && \
apt-get -yq install default-jre
RUN pip install -r requirements.txt
EXPOSE 5090
CMD ["python", "-u", "app.py"]


### C. Elastic search

As mentioned before it is the instance of elastic search with the rank lib plugin installed

Dockerfile

FROM docker.elastic.co/elasticsearch/elasticsearch:6.2.4
RUN /usr/share/elasticsearch/bin/elasticsearch-plugin install \
-b http://es-learn-to-rank.labs.o19s.com/ltr-1.1.0-es6.2.4.zip


All layers are composed with docker-compose.yml:

version: '2.2'
services:
elasticsearch:
build: ../docker/elasticsearch
container_name: elasticsearch
environment:
- discovery.type=single-node
- bootstrap.memory_lock=true
- xpack.security.enabled=false
- "ES_JAVA_OPTS=-Xms512m -Xmx512m"
ulimits:
memlock:
soft: -1
hard: -1
volumes:
- ../docker/elasticsearch/esdata1:/usr/share/elasticsearch/data
networks:
- esnet

training-app:
build: ../docker/training-app
networks:
- esnet
depends_on:
- elasticsearch
environment:
- ES_HOST=http://elasticsearch:9200
- ES_INDEX=tmdb
- ES_TYPE=movie
volumes:

nginx:
image: "nginx:1.13.5"
ports:
- "8020:80"
volumes:
- ../docker/frontend-reverse-proxy/conf:/etc/nginx/conf.d
- ../docker/frontend-reverse-proxy/www/data:/www/data
depends_on:
- elasticsearch
- training-app
networks:
- esnet

volumes:
esdata1:
driver: local

networks:
esnet:


# 2. Platform

The platform helps to run and understand the whole process thought four steps:

A. Indexing the data
B. Labeling the search results
C. Training the model
D. Testing trained model

### A. Indexing

The first step is obvious thus I will summarize it shortly. As mentioned before the default data source is taken from tmdb.json file but it can be simply changed using ES_DATA environment variable in the docker-compose.yml :

training-app:
environment:
- ES_HOST=http://elasticsearch:9200
- ES_INDEX=tmdb
- ES_TYPE=movie
- ES_FEATURE_SET_NAME=movie_features
- ES_MODEL_NAME=test_6
- ES_MODEL_TYPE=6
- ES_METRIC_TYPE=ERR@10


Clicking Prepare Index the data is taken from ES_DATA file and indexed in the elastic search.

ES_HOST – the elastic search url
ES_USER/ES_PASSWORD – elastic search credentials, by default authentication is turned off
ES_INDEX/ES_TYPE – index/type name for data from ES_DATA file
ES_FEATURE_SET_NAME – name of container for defined features (described later)
ES_MODEL_NAME – name of trained model kept in elastic search (described later)
ES_MODEL_TYPE – algorithm used to train the model (described later).
ES_METRIC_TYPE – metric type (described later)

We can train and keep multiple models in elastic search which can be used for A/B testing.

### B. Labeling

The supervised learning algorithms like learn to rank needs labeled data thus in this step I will focus on this area.
First of all I have to prepare the file label_list.json which contains the list of queries to label e.g.:

[
"rambo",
"terminator",
"babe",
"die hard",
"goonies"
]


When the file is ready I can go to the second tab (Step 2 Label).

For each query item the platform prepare the result candidates which have to be ranked from 0 to 4.

You have to go through the whole list and at the last step
the labeled movies are saved in the file :

# grade (0-4)   queryid docId   title
#
# Use them to populate your query templates
#
# qid:1: rambo
# qid:2: terminator
# qid:3: babe
# qid:4: die hard
#
# https://sourceforge.net/p/lemur/wiki/RankLib%20File%20Format/
#
#
4 qid:1 # 7555 Rambo
4 qid:1 # 1370 Rambo III
4 qid:1 # 1368 First Blood
4 qid:1 # 1369 Rambo: First Blood Part II
0 qid:1 # 31362 In the Line of Duty: The F.B.I. Murders
0 qid:1 # 13258 Son of Rambow
0 qid:1 # 61410 Spud
4 qid:2 # 218 The Terminator
4 qid:2 # 534 Terminator Salvation
4 qid:2 # 87101 Terminator Genisys
4 qid:2 # 61904 Lady Terminator
...


Each labeling cycle is saved to the separate file: timestamp_judgments.txt

### C. Training

Now it is time to use labeled data to make elastic search much more smarter. To do this we have to indicate the candidates features.
The features list is defined in the files: 1-4.json in the training-app directory.
Each feature file is elastic search query eg. the {{keyword}}
(which is searched text) match the title property:

{
"query": {
"match": {
"title": "{{keywords}}"
}
}
}


In this example I have used 4 features:
– title match keyword
– overview match keyword
– keyword is prefix of title
– keyword is prefix of overview

I can add more features without code modification, the list of features is defined and read using naming pattern (1-n.json).

Now I can go to the Step 3 Train tab and simply click the train button.

At the first stage the training app takes all feature files and build the features set which is save in the elastic search (the ES_FEATURE_SET_NAME environment variable defines the name of this set).

In the next step the latest labeling file (ordered by the timestamp) is processed (for each labeled item the feature values are loaded) eg.

4 qid:1 # 7555 Rambo


The app takes the document with id=7555 and gets the elastic search score for fetch defined feature.
The Rambo example is translated into:

4   qid:1   1:12.318446 2:10.573845 3:1.0   4:1.0 # 7555    rambo


Which means that score of feature one is 12.318446 (and respectively 10.573845, 1.0, 1.0 for features 2,3,4 ).
This format is readable for the RankLib library. And the training can be perfomed.
The full list of parameters is available on: [https://sourceforge.net/p/lemur/wiki/RankLib/][https://sourceforge.net/p/lemur/wiki/RankLib/].

The ranker type is chosen using ES_MODEL_TYPE parameter:
– 0: MART (gradient boosted regression tree)
– 1: RankNet
– 2: RankBoost
– 4: Coordinate Ascent
– 6: LambdaMART
– 7: ListNet
– 8: Random Forests

The default used value is LambdaMART.

Additionally setting ES_METRIC_TYPE we can use the optimization metric.
Possible values:
– MAP
– NDCG@k
– DCG@k
– P@k
– RR@k
– ERR@k

The default value is ERR@10

Finally we obtain the trained model which is deployed to the elastic search.
The project can deploy multiple trained models and the deployed model name is defined by ES_MODEL_NAME.

### D. Testing

In the last step we can test trained and deployed model.

We can choose the model using the ES_MODEL_NAME parameter.

It is used in the search query and can be different in each request which is useful when we need to perform A/B testing.

Happy searching 🙂

# Tensorflow meets C# Azure function

Tensorflow meets C# Azure function and … . In this post I would like to show how to deploy tensorflow model with C# Azure function. I will use the TensorflowSharp the .NET bindings to the tensorflow library. The InterceptionInterface will be involved to create http endpoint which will recognize the images.

## Code

dotnet new classlib
dotnet add package TensorFlowSharp -v 1.9.0


Then create file TensorflowImageClassification.cs:

Here I have defined the http entrypoint for the AzureFunction (Run method). The q query parameter is taken from the url and used as a url of the image which will be recognized.

The solution will analyze the image using the convolutional neural network arranged with the Interception architecture.

The function will automatically download the trained interception model thus the function first run will take little bit longer. The model will be saved to the D:\home\site\wwwroot\.

The convolutional neural network graph will be kept in the memory (graphCache) thus the function don’t have to read the model every request. On the other hand the input image tensor has to be prepared and preprocessed every time (ConstructGraphToNormalizeImage).

Finally I can run command:

dotnet publish


which will create the package for the function deployment.

## Azure function

To deploy the code I will create the Azure Function (Consumption) with the http trigger. Additionally I will set the function entry point, the function.json will be defined as:

The kudu will be used to deploy the already prepared package. Additionally I have to deploy the libtensorflow.dll from /runtimes/win7-x64/native (otherwise the Azure Functions won’t load it). The bin directory should look like:

Finally I can test the azure function:

The function recognize the image and returns the label with the highest probability.

# Another brick in the … recommendation system – Databricks in action

Today I’d like to investigate the Databricks. I will show how it works and how to prepare simple recommendation system using collaborative filtering algorithm which can be used to help to match the product to the expectations and preferences of the user. Collaborative filtering algorithm is extremely useful when we know the relations (eg ratings) between products and the users but it is difficult to indicate the most significant features.

## Databricks

First of all, I have to setup the databricks service where I can use Microsoft Azure Databricks or Databricks on AWS but the best way to start is to use the Community version.

### Data

In this example I use the movielens small dataset to create recommendations for the movies. After unzipping the package I use the ratings.csv file.
On the main page of Databrick click Upload Data and put the file.

The file will be located on the DBFS (Databrick file system) and will have a path /FileStore/tables/ratings.csv. Now I can start model training.

### Notebook

The data is ready thus in the next step I can create the databricks notebook (new notebook option on the databricks main page) similar to Jupyter notebook.

Using databricks I can prepare the recommendation in a few steps:

First of all I read and parse the data, because the data file contains the header additionally I have to cut it. In the next step I split the data into training which will be used to train the model and testing part for model evaluation.

I can simply create the ratings for each user/product pair but also export user and products (in this case movies) features. The features in general are meaningless factors but deeper analysis and intuition can give them meaning eg movie genre. The number of features is defined by the rank parameter in training method (used for model training).
The user/product rating is defined as a scalar product of user and product feature vectors.
This gives us ability to use them outside the databricks eg in relational database prefilter the movies using defined business rules and then order using user/product features.

Finally I have shown how to save the user and product features as a json and put it to Azure blob.

# Hello from serverless messanger chatbot

Messanger chatbots are now becoming more and more popular. They can help us order pizzas, ask about the weather or check the news.

In this article, I would like to show you how to build a simple messanger chatbot in python and pass it on AWS lambda. Additionally use the wit.ai service to add to it the natural language understanding functionality and make it more intelligent.

To build the messanger chatbot I will need facebook app and facebook page.

The whole communication is going through a Facebook page thus I need to create it

I will need the page id which you can find at the bottom of your page:

### Settings

I will copy the AppId and AppSecret which will be needed in the next steps:

### Messanger product

Then I will add the messanger product and setup it.

### Webhook

Finally I have to setup the webhooks for messanger product
To finish this step I need to setup our chatbot on aws lambda.
I also have to provide the verify token which will be used to validate our endpoint.

## AWS Lambda

Now I will prepare my chatbot endpoint. I will setup it on the AWS lambda.

### Trigger

For my chatbot I need to configure API Gateway.
I have to choose security open otherwise I won’t be able to call it from messanger

### Code

I also need to provide code which will handle the messanger webhook and send response.
I will simply put the code in the online editor.
Let’s take a look at the code:

### Configuration

Bellow I have to setup environment variables:
verify_token – verification token (I use keepass to generate it) which we will use in webhook setup
access_token – value from the messanger webhook page setup

Now I’m ready to finish the webhook configuration:

I use api gateway url ass Callback URL and verify_token I have just generated.

## Natural language undestanding

Messanger give easy way to add natural language undestanding functionality. To add this I simply configure it on messanger product setup page

Here I can choose already trained models but I will go further and I will create custom model.
Messanger will create the new wit.ai project for me.

On the wit.ai I can simply add some intents (like: hungry) and additional information which can be retrieved from the phrase (like: I want some pizza)

The messanger/wit integration is very smooth let’s analyze the webhook json I get when I put I want to eat pizza

After wit integration the nlp object was added. Now I can get the recognized intent with some confidence (like: hungry) and additional entities (like: dish).

Finally I can talk with my chatbot 🙂