Using Private Instance

3. The categorical operations scenario

Categorical computation means statistical operation of a column that meets the condition when a specific column has categorical values. It provides examples of categorical arithmetic computations and categorical statistical calculations provided by HOMEROS. Most of the operations provided in Chapter 02 are provided, and the next examples are additionally provided.

• Z test for the ratio of two binomial samples
• Confidence interval for the probability of a population through the Z distribution

4. Data concatenation scenario

Data combining provides scenarios for combined analysis by sharing data from different institutions or enterprises.

5. K means clustering prediction scenario

K means clustering is one of the representative clustering techniques, and is used in various situations, such as labeling unlabeled or partial data for supervised learning or classifying data according to their characteristics. It provides an example of the K means clustering inference function of encrypted data provided by HOMEROS.

6. Linear SVM prediction scenario

Linear Support Vector Machine (SVM) is a representative machine learning algorithm mainly used for classification or regression of linear data. It is widely used in various fields due to its powerful function that comes from a relatively simple structure. It provides an example of the Linear SVM inference function of encrypted data provided by HOMEROS.

7. Convolutional Neural Network with MNIST dataset prediction scenario

It provides an encrypted inference example of Convolutional Neural Network (CNN), the most used deep learning algorithm for image analysis. Based on MNIST, one of the most commonly used examples in image analysis, it provides encrypted inference of a 2D CNN algorithm, as well as inference of a CNN model trained with Pytorch.

8. Convolutional Neural Network with Fashion MNIST dataset prediction scenario

It provides an example of changing the inference dataset to Fashion MNIST in the CNN example in Chapter 07.

9. Linear Regression With training and prediction scenario

Linear Regression is a machine learning algorithm with powerful performance despite its simple structure. It provides examples of Linear Regression learning in an encrypted state from HOMEROS and inference by decrypting the trained encrypted model.

10. Logistic Regression With training and prediction scenario

Logistic Regression is a machine learning algorithm with powerful performance despite its simple structure. It provides examples of Logistic Regression learning in an encrypted state from HOMEROS and inference by decrypting the trained encrypted model.

11. Random forest prediction scenario

Random Forest is a representative ensemble machine learning model, and it is used in many fields to compensate for the disadvantage that Decision Tree is highly likely to be overfitting. It provides an example of encrypted random forest inference provided by HOMEROS.

12. XGBoost prediction scenario

If Random Forest is a representative ensemble model, XGBoost is a representative boosting machine learning model that provides both classification and regression, and is an algorithm that is used based on its popularity due to its good performance and resource efficiency. It provides an example of encrypted XGBoost inference provided by HOMEROS.

13. MLP(Multi Layers Perceptron) prediction scenario

Multi Layer Perceptron is the most basic deep learning model. It provides an example of encrypted MLP inference provided by HOMEROS.

SSH access

You can connect to the server via SSH while the instance is running. The procedure to access SSH is as follows.

1. In the VPC environment of NAVER Cloud Platform Console, click Services > Big Data & Analytics > HEaaN Homomorphic Analytics > Instances in this order.
2. Select the instance to access SSH from the instance list.
3. Copy the IP address from URL of Jupyter Notebook in Instance details.
4. You can access it through Terminal or PowerShell as follows. When connecting via SSH, enter the password set in the instance creation step.

>> ssh homeros@{SERVER_IP}
>> {JUPYTER_NOTEBOOK_PASSWORD}

Deploy applications

It describes how to deploy services using HOMEROS using Python-based development frameworks Flask and Django.

In the development environment, Web Application Server (WAS) can be configured with only the Flask or Django framework itself, but in the deployment environment, these limitations can be overcome through the Web Server Gateway Interface (WSGI) for performance and security. WSGI is an interface created for Python scripts to communicate efficiently with a web server.

This guide explains how to deploy applications using Gunicorn, one of the representative WSGI technologies, and Nginx, a representative web server that provides high speed, reverse proxy, and SSL.

1. Install Flask

(1) Install required package: Since the installation proceeds with the homeros account, not root, insert the --user option.

pip3 install flask --user
pip3 install MarkupSafe --user
pip3 install Jinja2 --user
pip3 install click --user

(2) Create a basic Flask application: Create an app.py file in the folder where the Flask project is created, and write the following code.

from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
    return 'Hello, World!'
if __name__ == '__main__':
    app.run(host='0.0.0.0', port=1080)

(3) Application integration with Gunicorn: In case of opening port 8000, execute the following command in the place where the app.py file is located.

gunicorn --bind 0.0.0.0:8000 app:app &

2. Install Django

(1) Install required package

python3 -m pip install Django --user

(2) Create django basic application: Execute the following command in the folder where the application will be created.

django-admin startproject mysite

(3) Application integration with Gunicorn: When opening port 8000 in the folder where the application name mysite is located, execute the following command.

gunicorn --bind 127.0.0.1:8000 mysite.wsgi:application &

3. Connect Nginx

(1) Install Nginx (based on the latest version 1.20.2)

Download the source code and proceed with the build. (The base folder is assumed to be /home/homeros/myproject/nginx)

wget https://nginx.org/download/nginx-1.20.2.tar.gz

Decompress the tar.gz file of the downloaded nginx.

tar zxvf nginx-1.20.2.tar.gz 

Change to the unzipped folder.

cd nginx-1.20.2

(2) Build

Configure settings: Set to create log files, config files, and sbin files containing executable files under the /home/homeros/myproject/nginx path.

./configure \
  --prefix=/home/homeros/myproject/nginx/ \
  --user=homeros \
  --group=homeros \
  --error-log-path=/home/homeros/myproject/nginx/error.log \
  --http-log-path=/home/homeros/myproject/nginx/access.log \
  --without-http_scgi_module \
  --without-http_uwsgi_module \
  --without-http_fastcgi_module \
  --with-stream

Run make

make

Run make install

make install

(3) Setting: Open the nginx.conf file at /home/homeros/myproject/nginx/conf and enter the following:

vim nginx.conf
server {
    listen $nginx port;
    …

    location / {
        proxy_pass http://127.0.0.1:$gunicorn port;
    }
}

For example, if the port connected with gunicorn is 8000 and you want to proxy it to port 8001 in nginx, edit it as follows.

server {
    listen  nginx 8001;
    …

    location / {
        proxy_pass http://127.0.0.1:8000;
    }
}

(4) Run nginx

/home/homeros/myproject/nginx/sbin/nginx

(5) Close nginx

/home/homeros/myproject/nginx/sbin/nginx -s stop

Delete cache data

If temporary files used by HOMEROS are not automatically deleted, you may run out of storage capacity. If work is impossible due to lack of storage space, you can secure additional storage space by deleting temporary files.

1. Running Jupyter notebook shutdown

Temporary files are deleted when the running Jupyter Notebook is shut down.

If Jupyter Notebook is shut down but storage space is not secured, you can manually delete temporary files.

2. Delete cache data

(1) Terminal access: Terminal access is possible through [New] >> [Terminal] at the top right of Jupyter Notebook.

>> ssh homeros@{SERVER_IP}
>> {JUPYTER_NOTEBOOK_PASSWORD}

(2) Check storage space

>> df -h

If the space under /home is insufficient, use the following command to check the capacity of the /home/homeros/.homeros/ folder.

du -sh /home/homeros/.homeros/

(3) Delete temporary files under .homeros: If the capacity of the .homeros folder is insufficient, delete temporary files in the .homeros directory to secure storage space.

>> rm -rf /home/homeros/.homeros/*