From 47b519cb5aa9a33792b2433d7dbe6c16884ffd67 Mon Sep 17 00:00:00 2001
From: lpetrov02 <lpetrov02@mail.ru>
Date: Fri, 15 Dec 2023 09:56:59 +0300
Subject: [PATCH 1/6] Started migration from Data2dLayer to DataLayer

Makes preparations for metrics logging on python
Functionality for c++ http added, but not working yet
Adds saving train metrics
Adds saving train metrics and responding with PNG

Adaptates code for new 4D blob

cpprest CI support
Add load possibility for zip
Add load possibility for png on predict
-------
GRA-122: Data loader implementation (#67)
Data loader implementation
-------
ID-154: Loss type selection (#70)
* Add loss type selection
* Add loss type selection
* Remove layer-class loss
* Clean up Loss type
* Make format
-------
ID-171: Fix input selection (#69)
* Fix input selection
* Clean up fix input selection
-------
Change train and predict for zip file case
Starts fixing train
Fixes train with dataloader
It's not fucking working :( (x3)
server train fix
Fixes train and predcit
---
 .github/workflows/CI.yml                 |   3 +
 .gitignore                               |   3 +-
 README.md                                |   3 +
 client/templates/main.html               |  18 +-
 py_server/Makefile                       |   2 +-
 py_server/mlcraft/check_dimensions.py    |   6 +-
 py_server/mlcraft/dataset.py             |  14 +-
 py_server/mlcraft/db.py                  |  83 ++++++-
 py_server/mlcraft/server.py              |  99 ++++++--
 py_server/mlcraft/static/swagger.yaml    | 283 ++++++++++++++++++++---
 py_server/mlcraft/utils.py               |  17 ++
 py_server/pyproject.toml                 |   1 +
 py_server/tests/test_check_dimensions.py |  16 +-
 server/Makefile                          |   8 +-
 server/api/DataLoader.cpp                |  26 +--
 server/api/DataLoader.h                  |   1 +
 server/api/GraphBuilder.cpp              |  97 ++++----
 server/api/GraphBuilder.h                |  27 ++-
 server/api/Parser.cpp                    |  38 +--
 server/api/Parser.h                      |   4 +-
 server/api/server.cpp                    | 211 +++++++++++++----
 server/core/Allocator.cpp                |   2 +-
 server/core/Layer.cpp                    |  13 +-
 server/core/Layer.h                      |   7 +-
 server/core/LazyBlob.cpp                 |   6 +-
 server/core/Operation.h                  |   5 +
 server/core/Optimizer.cpp                |  11 +-
 server/core/Optimizer.h                  |  12 +-
 server/core/Parameters.h                 |   5 -
 server/tests/linear_relu_linear_mse.json |   4 +-
 30 files changed, 781 insertions(+), 244 deletions(-)

diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
index 9798a4d5..adea88ef 100644
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -52,6 +52,9 @@ jobs:
           sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 90
           sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-11 90
 
+      - name: install-cpprest
+        run: sudo apt install libcpprest-dev
+
       - name: install-boost
         uses: MarkusJx/install-boost@v2.4.4
         id: install-boost
diff --git a/.gitignore b/.gitignore
index 901ef702..48b197a5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -21,6 +21,7 @@ __pycache__/
 *$py.class
 .cache
 .venv
+images/
 
 # Flask stuff:
 instance/
@@ -49,4 +50,4 @@ dmypy.json
 # Makefile
 install
 bin
-*.patch
\ No newline at end of file
+*.patch
diff --git a/README.md b/README.md
index 019427b8..97c2050c 100644
--- a/README.md
+++ b/README.md
@@ -85,6 +85,9 @@ Other targets available:
 > **Important:** If you want to build a c++ server, you need to install [Boost](https://www.boost.org/users/download/).  
 > Then, **in the `config.json` file** add the path to the boost root (folder with `include` and `lib` inside).  
 > For example: `"BOOST_ROOT": "/usr/local/Cellar/boost/1.81.0_1"`  
+
+> Also you need `cpprest`: on MacOS: `brew install cpprestsdk`  
+> on Linux: `sudo apt-get install libcpprest-dev`  
 > After that you should be able to build everything just fine...
 
 There are 3(4) main targets available to build:
diff --git a/client/templates/main.html b/client/templates/main.html
index c62663e7..01a7dfd3 100644
--- a/client/templates/main.html
+++ b/client/templates/main.html
@@ -174,7 +174,7 @@ <h3></h3>
           </div>
         </div>
 
-        <div class="relu-layer-parameters layer-parameters" id="relu-layer-parameters" style="display: none">
+        <div class="relu-layer-parameters" id="relu-layer-parameters" style="display: none">
           <label for="relu-width-parameter">Width</label>
           <input id="relu-width-parameter" type="number" value="1" size="4" />
           <h3></h3>
@@ -227,7 +227,7 @@ <h3></h3>
           </div>
         </div>
 
-        <div class="loss-layer-parameters layer-parameters" id="loss-layer-parameters" style="display: none">
+        <div class="loss-layer-parameters" id="loss-layer-parameters" style="display: none">
           <label for="loss-width-parameter">Width</label>
           <input id="loss-width-parameter" type="number" value="1" size="4" />
           <h3></h3>
@@ -395,15 +395,15 @@ <h3></h3>
             target: "Target",
           }
           const parametersMap = {
-            linear: "bias=0;inFeatures=1;outFeatures=2",
+            linear: "bias=0;inFeatures=2;outFeatures=1",
             relu: "",
             pooling: "",
             layernorm: "axis=1",
             conv2d: "KernelSize=1;inChannels=1;outChannels=1",
-            data: "width=2",
-            output: "width=1",
-            loss: "width=1",
-            target: "width=1",
+            data: "shape=[2]",
+            output: "",
+            loss: "",
+            target: "shape=[1]",
           }
           const layer = {
             type: nameMap[name],
@@ -1381,7 +1381,7 @@ <h3></h3>
 
         // Input selection
         writeIdOnConnections(input_selection_layer_id)
-        let sortable_list = getSortableInputList(node)
+        let sortable_list = getSortableInputList(node.class)
         let child = sortable_list.lastElementChild
 
         while (child) {
@@ -1419,7 +1419,7 @@ <h3></h3>
             matchConnectionsAfterSelection(new_input_order)
           },
         })
-        document.getElementById("layer-id").innerHTML = "ID: " + layer_dbid.toString()
+
         document.getElementById("layer-data").style.display = "block"
         setupLayerParameters(node, correct_id)
       }
diff --git a/py_server/Makefile b/py_server/Makefile
index 22184a56..c30780e5 100644
--- a/py_server/Makefile
+++ b/py_server/Makefile
@@ -83,4 +83,4 @@ $(dirEnv):
 
 clean:
 	$(RM) install
-	$(RM) -r instance
+	$(RM) -r instance
\ No newline at end of file
diff --git a/py_server/mlcraft/check_dimensions.py b/py_server/mlcraft/check_dimensions.py
index 772e928d..5147ff80 100644
--- a/py_server/mlcraft/check_dimensions.py
+++ b/py_server/mlcraft/check_dimensions.py
@@ -6,8 +6,8 @@
 
 
 class Data2dChecker:
-    def __init__(self, width):
-        self.output_shape = [-1, width]
+    def __init__(self, shape: list[int]):
+        self.output_shape = [-1] + shape
 
     def __call__(self):
         return True
@@ -60,7 +60,7 @@ def __call__(self, input_shape: list[int], targets_shape: list[int]):
 def create_checker(layer: dict):
     match layer["type"]:
         case "Data" | "Target":
-            return Data2dChecker(layer["parameters"]["width"])
+            return Data2dChecker(layer["parameters"]["shape"])
         case "Linear":
             return LinearChecker(
                 layer["parameters"]["inFeatures"], layer["parameters"]["outFeatures"]
diff --git a/py_server/mlcraft/dataset.py b/py_server/mlcraft/dataset.py
index 79fcc2ab..5fe8bc99 100644
--- a/py_server/mlcraft/dataset.py
+++ b/py_server/mlcraft/dataset.py
@@ -1,4 +1,6 @@
 import csv
+import math
+
 from http import HTTPStatus
 from io import StringIO
 from .errors import Error
@@ -19,10 +21,10 @@ def extract_train_data(bytes: bytes, model: dict) -> dict:
 
     data: list[float] = []
     target: list[float] = []
+    dims = list(map(int, data_layer["parameters"]["shape"]))
+    dims_total = math.prod(dims)
     for row in reader:
-        if (
-            int(data_layer["parameters"]["width"]) != len(row) - 1
-        ):  # columns = features + 1 for target
+        if dims_total != len(row) - 1:  # columns = features + 1 for target
             raise Error("Input csv column count doesn't match data's feature count")
 
         data.extend(map(float, row[:-1]))
@@ -36,11 +38,11 @@ def extract_predict_data(bytes: bytes, model: dict) -> dict:
     reader = csv.reader(StringIO(bytes.decode()))
     row = next(reader, None)
 
+    dims = list(map(int, data_layer["parameters"]["shape"]))
+    dims_total = math.prod(dims)
     if row is None:
         raise Error("Bad csv format")
-    if int(data_layer["parameters"]["width"]) != len(
-        row
-    ):  # predict request - one row with data only
+    if dims_total != len(row):  # predict request - one row with data only
         raise Error("Input csv column count doesn't match data's feature count")
 
     return {data_layer["id"]: list(map(float, row))}
diff --git a/py_server/mlcraft/db.py b/py_server/mlcraft/db.py
index 92cd2776..5220a7cd 100644
--- a/py_server/mlcraft/db.py
+++ b/py_server/mlcraft/db.py
@@ -1,4 +1,5 @@
 from threading import Lock  # fuck it, just using old robust methods
+import datetime
 import json
 from sqlite3 import IntegrityError
 from flask import current_app
@@ -31,6 +32,18 @@ class Model(db.Model):  # type: ignore
     raw = db.Column(db.Text)
 
 
+class Metrics(db.Model):  # type: ignore
+    __tablename__ = "metrics_table"
+
+    id = db.Column(db.Integer, primary_key=True)
+    model = db.Column(db.Integer, db.ForeignKey("users_table.id"), nullable=False)
+    label = db.Column(db.Text)
+    values = db.Column(db.Text)
+    begin_time = db.Column(db.DateTime)
+    end_time = db.Column(db.DateTime)
+    protected = db.Column(db.Boolean)
+
+
 class SQLWorker:
     """
     Important: whenever you work with 'content' column of the model,
@@ -301,9 +314,6 @@ def verify_connection(
                 )
             layer1 = layer1_candidates[0]
             layer2 = layer2_candidates[0]
-            # TO BE DONE later
-            # if not self.check_dimensions(layer1, layer2):
-            #     return LayersConnectionStatus.DimensionsMismatch
             if layer2["type"] == "Data" or layer1["type"] == "Output":
                 raise Error(
                     "Wrong direction in data or output layer",
@@ -340,6 +350,73 @@ def is_model_trained(self, model_id: int):
             model = self.get_model(model_id)
             return model.is_trained
 
+    def update_metrics(self, model_id, values: list[float], label: str, rewrite: bool):
+        with current_app.app_context(), self.content_lock:
+            metrics = (
+                Metrics.query.filter_by(model=model_id, label=label)
+                .order_by(Metrics.id.desc())
+                .first()
+            )
+            if not metrics:
+                metrics = Metrics()
+                metrics.model = model_id
+                metrics.label = label
+                metrics.values = " ".join(list(map(str, values)))
+                metrics.begin_time = datetime.datetime.now()
+                metrics.end_time = datetime.datetime.now()
+                metrics.protected = False
+            if rewrite:
+                metrics.values = ""
+            else:
+                metrics.values += " "
+            metrics.values += " ".join(list(map(str, values)))
+            metrics.end_time = datetime.datetime.now()
+            db.session.add(metrics)
+            db.session.commit()
+            return 0
+
+    def protect_metrics(self, model_id, label: str, protected: bool):
+        with current_app.app_context(), self.content_lock:
+            metrics = (
+                Metrics.query.filter_by(model=model_id, label=label)
+                .order_by(Metrics.id.desc())
+                .first()
+            )
+            if not metrics:
+                raise Error(
+                    f"No recordings found for model with id {model_id} and label {label}.",
+                    HTTPStatus.NOT_FOUND,
+                )
+            metrics.protected = protected
+            db.session.add(metrics)
+            db.session.commit()
+            return 0
+
+    def get_metrics(self, model_id, label: str) -> str:
+        with current_app.app_context(), self.content_lock:
+            metrics = (
+                Metrics.query.filter_by(model=model_id, label=label)
+                .order_by(Metrics.id.desc())
+                .first()
+            )
+            if not metrics:
+                raise Error(
+                    f"No recordings found for model with id {model_id} and label {label}.",
+                    HTTPStatus.NOT_FOUND,
+                )
+            return metrics.values
+
+    # Пока без ручки, просто как напоминание о том, что метрики нужно чистить
+    def delete_old_metrics(self):
+        with current_app.app_context(), self.content_lock:
+            Metrics.query.filter(
+                Metrics.end_time < datetime.datetime.now() - datetime.timedelta(days=30)
+            ).delete()
+            Metrics.query.filter(
+                Metrics.end_time < datetime.datetime.now() - datetime.timedelta(days=1)
+            ).filter_by(protected=False).delete()
+            db.session.commit()
+
 
 sql_worker: SQLWorker = None  # type: ignore
 
diff --git a/py_server/mlcraft/server.py b/py_server/mlcraft/server.py
index 8aa33f7e..a650235d 100644
--- a/py_server/mlcraft/server.py
+++ b/py_server/mlcraft/server.py
@@ -1,8 +1,19 @@
+from json import dumps
+from sqlite3 import IntegrityError
+import datetime
 import requests
 from http import HTTPStatus
-from flask import Blueprint, request, current_app
-
-from .utils import convert_model_parameters, is_valid_model, convert_model
+from flask import Blueprint, request, current_app, send_file
+import numpy as np
+import os
+
+from .utils import (
+    convert_model_parameters,
+    is_valid_model,
+    convert_model,
+    plot_metrics,
+    delete_file,
+)
 from .check_dimensions import assert_dimensions_match
 
 from .errors import Error
@@ -142,8 +153,6 @@ def train_model(
 ):  # Unfortunately, flask don't have convertor for bool
     # checks belonging of the model to user
     sql_worker.verify_access(user_id, model_id)
-    if not request.data:
-        raise Error("No csv data provided")
     if sql_worker.is_model_trained(model_id) and safe:
         raise Error("Already trained", HTTPStatus.PRECONDITION_FAILED)
 
@@ -153,13 +162,11 @@ def train_model(
         raise Error("Invalid model found", HTTPStatus.NOT_ACCEPTABLE)
     assert_dimensions_match(model["layers"])
 
-    dataset = extract_train_data(request.data, model)
-
     convert_model(model)
-    model = {"graph": model, "dataset": dataset}
+    model = {"graph": model}
 
     response = requests.post(
-        current_app.config["CPP_SERVER"] + f"/train/{model_id}",
+        current_app.config["CPP_SERVER"] + f"/train/{user_id}/{model_id}",
         json=model,
         timeout=3,
     )
@@ -172,20 +179,82 @@ def train_model(
 def predict(user_id: int, model_id: int):
     sql_worker.verify_access(user_id, model_id)
 
-    if not request.data:
-        raise Error("No csv data provided")
-
     model = sql_worker.get_graph_elements(model_id)
     convert_model_parameters(model)
-    json_data = extract_predict_data(request.data, model)
 
     if not sql_worker.is_model_trained(model_id):
         raise Error("Not trained", HTTPStatus.PRECONDITION_FAILED)
 
-    response = requests.post(
+    response = requests.put(
         current_app.config["CPP_SERVER"] + f"/predict/{model_id}",
-        json=json_data,
         timeout=3,
     )
 
     return response.text, response.status_code
+
+
+@app.route("/update_metrics/<int:user_id>/<int:model_id>", methods=["PUT"])
+def update_metrics(user_id: int, model_id: int):
+    sql_worker.verify_access(user_id, model_id)
+
+    json = request.json or {}
+    targets = np.array(json["targets"])
+    n_epochs, n_samples = targets.shape
+    outputs = np.array(json["outputs"])
+    if targets.shape != outputs.shape:
+        outputs = outputs.reshape(n_epochs, n_samples, -1)
+
+    assert targets.shape == outputs.shape  # Это временное
+    metrics = np.mean((targets - outputs) ** 2, axis=1)
+    sql_worker.update_metrics(
+        model_id,
+        list(metrics),
+        json.get("label", "default"),
+        json.get("rewrite", False),
+    )
+    return "", HTTPStatus.OK
+
+
+@app.route("/protect_metrics/<int:user_id>/<int:model_id>", methods=["PUT"])
+def protect_metrics(user_id: int, model_id: int):
+    sql_worker.verify_access(user_id, model_id)
+
+    json = request.json or {}
+    sql_worker.protect_metrics(
+        model_id,
+        json.get("label", "default"),
+        json.get("protected", True),
+    )
+    return "", HTTPStatus.OK
+
+
+@app.route("/get_metrics/<int:user_id>/<int:model_id>", methods=["PUT"])
+def get_metircs(user_id: int, model_id: int):
+    sql_worker.verify_access(user_id, model_id)
+
+    json = request.json or {}
+    values = sql_worker.get_metrics(
+        model_id,
+        json.get("label", "default"),
+    )
+    return {"values": list(map(float, values.split()))}, HTTPStatus.OK
+
+
+# Add swagger description
+@app.route("/get_plots/<int:user_id>/<int:model_id>", methods=["PUT"])
+def get_plots(user_id: int, model_id: int):
+    sql_worker.verify_access(user_id, model_id)
+
+    json = request.json or {}
+    label = json.get("label", "default")
+    values = sql_worker.get_metrics(
+        model_id,
+        label,
+    )
+
+    plot_path = plot_metrics(list(map(float, values.split())), user_id, model_id, label)
+    current_dir = os.getcwd()
+    print(current_dir)
+    response = send_file(os.path.join(current_dir, "images", plot_path))
+    # delete_file(os.path.join(current_dir, "images", plot_path))
+    return response
diff --git a/py_server/mlcraft/static/swagger.yaml b/py_server/mlcraft/static/swagger.yaml
index 6522c0f3..ed48beda 100644
--- a/py_server/mlcraft/static/swagger.yaml
+++ b/py_server/mlcraft/static/swagger.yaml
@@ -173,7 +173,7 @@ paths:
         '403':
           $ref: '#/components/responses/ModelForbidden'
         '404':
-          $ref: '#components/responses/ModelNotFound'
+          $ref: '#/components/responses/ModelNotFound'
     put:
       tags: 
       - model
@@ -479,18 +479,11 @@ paths:
         - $ref: '#/components/parameters/ModelId'
         - name: safe
           in: path
-          description: flag, if 1, then the training process will be started even if the model is already trained
+          description: flag, if 0, then the training process will be started even if the model is already trained
           required: true
           schema:
             type: integer
             format: int64
-      requestBody:
-        description: "Data for training"
-        required: true
-        content:
-          text/csv:
-            schema:
-              $ref: '#/components/schemas/TrainData'
       responses:
         '200':
           description: "Model is trained"
@@ -532,13 +525,6 @@ paths:
       parameters:
         - $ref: '#/components/parameters/UserId'
         - $ref: '#/components/parameters/ModelId'
-      requestBody:
-        description: "Data for predictions"
-        required: true
-        content:
-          text/csv:
-            schema:
-              $ref: '#/components/schemas/PredictData'
       responses:
         '200':
           description: "Prediction was successful"
@@ -568,6 +554,213 @@ paths:
             application/json:
               schema:
                 $ref: '#/components/schemas/Error'
+  /update_metrics/{user_id}/{model_id}:
+    put:
+      tags:
+      - use
+      summary: "Writes new values of a metric"
+      description: "WRITES metric values"
+      operationId: "updates_metrics"
+      parameters:
+        - name: user_id
+          in: path
+          description: model owner's ID
+          required: true
+          schema:
+            type: integer
+            format: int64
+        - name: model_id
+          in: path
+          description: model's ID
+          required: true
+          schema:
+            type: integer
+            format: int64
+      requestBody:
+        description: "Information about new metric's values"
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/WriteMetricValues'
+      responses:
+        '200':
+          description: "Metrics updated successfully"
+        '400':
+          description: "Json isn't provided or required fields missing"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+        '403':
+          description: "The model does not exist or you have no rights for changing it"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+        '404':
+          description: "Model / layer does not exist"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+  /protect_metrics/{user_id}/{model_id}:
+    put:
+      tags:
+      - use
+      summary: "Protects model's metrics from auto-deletion"
+      description: "PROTECTS metric values"
+      operationId: "protect_metrics"
+      parameters:
+        - name: user_id
+          in: path
+          description: model owner's ID
+          required: true
+          schema:
+            type: integer
+            format: int64
+        - name: model_id
+          in: path
+          description: model's ID
+          required: true
+          schema:
+            type: integer
+            format: int64
+      requestBody:
+        description: "Whar record to protect"
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ProtectMetricValues'
+      responses:
+        '200':
+          description: "Settings updated successfully"
+        '400':
+          description: "Json isn't provided or required fields missing"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+        '403':
+          description: "The model does not exist or you have no rights for changing it"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+        '404':
+          description: "Model / layer does not exist"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+  /get_metrics/{user_id}/{model_id}:
+    put:
+      tags:
+      - use
+      summary: "Reads metric's values from database"
+      description: "READS metric values"
+      operationId: "get_metrics"
+      parameters:
+        - name: user_id
+          in: path
+          description: model owner's ID
+          required: true
+          schema:
+            type: integer
+            format: int64
+        - name: model_id
+          in: path
+          description: model's ID
+          required: true
+          schema:
+            type: integer
+            format: int64
+      requestBody:
+        description: "Information about metric's values to read"
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ReadMetricValues'
+      responses:
+        '200':
+          description: "Successful read"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/ReturnMetricValues'
+        '400':
+          description: "Json isn't provided or required fields missing"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+        '403':
+          description: "The model does not exist or you have no rights for changing it"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+        '404':
+          description: "Model / layer does not exist"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+  /get_plots/{user_id}/{model_id}:
+    put:
+      tags:
+      - use
+      summary: "Get plot of metrics from the database"
+      description: "PLOTS metric values"
+      operationId: "get_plots"
+      parameters:
+        - name: user_id
+          in: path
+          description: model owner's ID
+          required: true
+          schema:
+            type: integer
+            format: int64
+        - name: model_id
+          in: path
+          description: model's ID
+          required: true
+          schema:
+            type: integer
+            format: int64
+      requestBody:
+        description: "Information about metric's values to read"
+        required: true
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/ReadMetricValues'
+      responses:
+        '200':
+          description: "Returns PNG"
+          schema:
+            type: file
+        '400':
+          description: "Json isn't provided or required fields missing"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+        '403':
+          description: "The model does not exist or you have no rights for changing it"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+        '404':
+          description: "Model / layer does not exist"
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Error'
+          
 components:
   schemas:
     User:
@@ -640,6 +833,37 @@ components:
           type: integer
           format: int64
           example: 2
+    WriteMetricValues:
+      type: object
+      properties:
+        values:
+          type: array
+          items:
+            type: string
+          example: [0.25, 0.112, 0.787, 0.238, 0.030, 0.0003]
+        label:
+          type: string
+          example: "train"
+        new_iteration:
+          type: boolean
+          example: true
+      required:
+        - values
+    ProtectMetricValues:
+      type: object
+      properties:
+        label:
+          type: string
+          example: "train"
+        protected:
+          type: boolean
+          example: true
+    ReadMetricValues:
+      type: object
+      properties:
+        label:
+          type: string
+          example: "train"
     Data:
       type: object
       properties:
@@ -648,28 +872,18 @@ components:
           items:
             type: number
             example: [0.0, 0.0, 0.0, 1.0]
-    TrainData:
-      type: string
-      description: |-
-        Last column is for the target value 
-        and all other columns are features values
-      example: |-
-        0,0,0
-        0,1,1
-        1,0,1
-        1,1,1
-    PredictData:
-      type: string
-      description: Only ONE row for now, a column for every feature
-      example: |-
-        1,1
     PredictResult:
       type: array
-      descriptoin: Array with 1 element for now
       items:
         type: number
         format: float
       example: [1.0]
+    ReturnMetricValues:
+      type: array
+      items:
+        type: number
+        format: float
+      example: [0.25, 0.112, 0.787, 0.238, 0.030, 0.0003]
     Error:
       type: object
       properties:
@@ -684,7 +898,7 @@ components:
           example: "Something whent wrong"
         problemPart:
           type: string
-          example: "The problem is in the Retrograde Mercury"
+          example: "The problem is here: ..."
   parameters:
     UserId: 
       name: user_id
@@ -743,9 +957,6 @@ components:
             $ref: '#/components/schemas/Error'
     NoJson:
       description: "Json not provided"
-      content:
-        text/html:
-          type: string
     NoField:
       description: "Required field is missing"
       content:
diff --git a/py_server/mlcraft/utils.py b/py_server/mlcraft/utils.py
index 3228066f..0dec6e2a 100644
--- a/py_server/mlcraft/utils.py
+++ b/py_server/mlcraft/utils.py
@@ -1,7 +1,10 @@
 import re
+import os
+import datetime
 import typing as tp
 from enum import Enum
 from collections import deque, defaultdict
+import matplotlib.pyplot as plt
 
 
 def get_edges_from_model(model_dict):
@@ -123,3 +126,17 @@ def convert_model(model):
             model["layers"],
         )
     )
+
+
+def plot_metrics(values: list[float], user_id: int, model_id: int, label: str) -> str:
+    dt = datetime.datetime.now()
+    plt.plot(list(range(1, len(values) + 1)), values)
+    isoformat_dt = re.sub(r"[:\.\-]", "_", dt.isoformat())
+    path = f"{user_id}_{model_id}_{label}_{isoformat_dt}.png"
+    plt.savefig(os.path.join("images", path))
+    return path
+
+
+def delete_file(path: str):
+    if os.path.exists(path):
+        os.remove(path)
diff --git a/py_server/pyproject.toml b/py_server/pyproject.toml
index 50c0d46f..efbc3eb8 100644
--- a/py_server/pyproject.toml
+++ b/py_server/pyproject.toml
@@ -14,6 +14,7 @@ dependencies = [
     "black == 23.10.1",
     "pytest == 7.4.2",
     "mypy == 1.6.1",
+    "matplotlib == 3.8.2",
 ]
 
 [build-system]
diff --git a/py_server/tests/test_check_dimensions.py b/py_server/tests/test_check_dimensions.py
index 705f5e36..35cdbf20 100644
--- a/py_server/tests/test_check_dimensions.py
+++ b/py_server/tests/test_check_dimensions.py
@@ -5,8 +5,8 @@
 
 def test_correct_simple():
     layers = [
-        {"id": 0, "type": "Target", "parameters": {"width": 1}, "parents": []},
-        {"id": 1, "type": "Data", "parameters": {"width": 2}, "parents": []},
+        {"id": 0, "type": "Target", "parameters": {"shape": [1]}, "parents": []},
+        {"id": 1, "type": "Data", "parameters": {"shape": [2]}, "parents": []},
         {
             "id": 2,
             "type": "Linear",
@@ -23,8 +23,8 @@ def test_correct_simple():
 
 def test_correct_harder():
     layers = [
-        {"id": 0, "type": "Target", "parameters": {"width": 1}, "parents": []},
-        {"id": 1, "type": "Data", "parameters": {"width": 2}, "parents": []},
+        {"id": 0, "type": "Target", "parameters": {"shape": [1]}, "parents": []},
+        {"id": 1, "type": "Data", "parameters": {"shape": [2]}, "parents": []},
         {
             "id": 2,
             "type": "Linear",
@@ -55,8 +55,8 @@ def test_correct_harder():
 
 def test_mismatch_simple():
     layers = [
-        {"id": 0, "type": "Target", "parameters": {"width": 1}, "parents": []},
-        {"id": 1, "type": "Data", "parameters": {"width": 2}, "parents": []},
+        {"id": 0, "type": "Target", "parameters": {"shape": [1]}, "parents": []},
+        {"id": 1, "type": "Data", "parameters": {"shape": [2]}, "parents": []},
         {
             "id": 2,
             "type": "Linear",
@@ -77,8 +77,8 @@ def test_mismatch_simple():
 
 def test_mismatch_harder():
     layers = [
-        {"id": 0, "type": "Target", "parameters": {"width": 1}, "parents": []},
-        {"id": 1, "type": "Data", "parameters": {"width": 2}, "parents": []},
+        {"id": 0, "type": "Target", "parameters": {"shape": [1]}, "parents": []},
+        {"id": 1, "type": "Data", "parameters": {"shape": [2]}, "parents": []},
         {
             "id": 2,
             "type": "Linear",
diff --git a/server/Makefile b/server/Makefile
index 35cbc71c..b3f865fa 100644
--- a/server/Makefile
+++ b/server/Makefile
@@ -12,11 +12,9 @@ CPPFLAGS = -I $(dirCore) -isystem $(dirApi)
 
 # C++ compiler flags
 maxErrors = 4 # number of errors compiler will print to the console
-# LDFLAGS = -lX11
 CXXFLAGS = -std=c++20 -pthread
-CXXFLAGS += -Wall -Wextra -pedantic 
+CXXFLAGS += -Wall -Wextra -pedantic
 CXXFLAGS += -fmax-errors=$(maxErrors) # for g++
-# CXXFLAGS += -lX11 -lm
 # CXXFLAGS += -ferror-limit=$(maxErrors) # uncomment for clang
 CXXFLAGS += -Wno-sign-compare
 CXXFLAGS += -Wno-unused-parameter
@@ -128,7 +126,7 @@ serve: $(server) | $(dirTrain) $(dirPredict)
 	$< $(host) $(port)
 
 $(server): $(serverMain) $(serverObjects) $(coreArchive) | checkboost $(dirBin)
-	$(LINK.cpp) -L $(boost)/lib $^ -o $@ -lX11 -lpng
+	$(LINK.cpp) -L $(boost)/lib $^ -o $@ -lX11 -lpng -lcpprest -lssl -lcrypto -lzip
 
 
 ### TESTS ###
@@ -164,7 +162,7 @@ checkboost:
 		fi; \
 	fi
 
-$(dirPredict) $(dirTrain): $(dirModelData) ; mkdir $@
+$(dirPredict) $(dirTrain): $(dirModelData) ; mkdir -p $@
 
 $(dirModelData) $(dirBuild) $(dirBin): ; mkdir $@
 
diff --git a/server/api/DataLoader.cpp b/server/api/DataLoader.cpp
index 9c643ed4..6c2149f3 100644
--- a/server/api/DataLoader.cpp
+++ b/server/api/DataLoader.cpp
@@ -41,36 +41,34 @@ std::size_t DataLoader::size() const {
     return loader->size();
 }
 
+std::size_t DataLoader::batch_count() const {
+    return (loader->size() + batch_size - 1) / batch_size;
+}
+
 void DataLoader::add_data(const DataLoader& other, int index) {
     loader->add_data(other.loader, index);
 }
 
-std::pair<std::vector<float>, std::vector<float>> DataLoader::get_raw(std::size_t index) const { // batch_size lines from index
-    if (index >= loader->size()) {
+std::pair<std::vector<float>, std::vector<float>> DataLoader::get_raw(std::size_t batch_index) const { // batch_size lines from index
+    if (batch_index >= batch_count()) {
         throw std::out_of_range("Index out of range");
     }
     std::vector<float> data;
     std::vector<float> res(batch_size, 0);
-    Shape shape = loader->get_appropriate_shape(rearrangement[index], batch_size);
-    auto dims = shape.getDims();
-    int data_size = 1;
-    for (int i = 0; i < dims.size(); ++i) {
-        data_size *= dims[i];
-    }
-    data.resize(data_size, 0);
+    Shape shape = loader->get_appropriate_shape(rearrangement[batch_index], batch_size);
+    data.resize(shape.size(), 0);
     int cur_data = 0;
-    for (int i = index; i < index + batch_size; ++i) {
+    for (int i = batch_size * batch_index; i < batch_size * (batch_index + 1); ++i) {
         if (i >= loader->size()) {
             break;
         }
         auto line = loader->get_raw(rearrangement[i]);
-        res[i - index] = line.second;
+        res[i - batch_size * batch_index] = line.second;
         for (int j = 0; j < line.first.size(); ++j) {
-            data[cur_data] = line.first[j];
-            cur_data++;
+            data[cur_data++] = line.first[j];
         }
     }
-    return {data, res};
+    return {std::move(data), std::move(res)};
 }
 
 void DataLoader::shuffle() {
diff --git a/server/api/DataLoader.h b/server/api/DataLoader.h
index a10582cb..b87d1931 100644
--- a/server/api/DataLoader.h
+++ b/server/api/DataLoader.h
@@ -18,6 +18,7 @@ class DataLoader {
     std::pair<Blob, std::vector<float>> operator[](std::size_t index) const;
     void add_data(const DataLoader& other, int index);
     std::size_t size() const;
+    std::size_t batch_count() const;
     std::pair<std::vector<float>, std::vector<float>> get_raw(std::size_t index) const;
     void shuffle();
 };
diff --git a/server/api/GraphBuilder.cpp b/server/api/GraphBuilder.cpp
index d52f41bf..def35368 100644
--- a/server/api/GraphBuilder.cpp
+++ b/server/api/GraphBuilder.cpp
@@ -2,12 +2,7 @@
 #include "Allocator.h"
 
 void Graph::OverviewLayers(const crow::json::rvalue& layers, 
-                           const std::vector<std::vector<float>>& data,
-                           std::unordered_map<int, crow::json::rvalue>& layer_dicts,
-                           std::unordered_map<int, std::vector<float>>& data_dicts) {
-    std::vector<float> instances;
-    std::vector<float> answers;
-    ParseCsvData(data, instances, answers);
+                           std::unordered_map<int, crow::json::rvalue>& layer_dicts) {
     for (auto& layer : layers) {
         CHECK_HAS_FIELD(layer, "id");
         CHECK_HAS_FIELD(layer, "type");
@@ -16,21 +11,13 @@ void Graph::OverviewLayers(const crow::json::rvalue& layers,
 
         layerTypes_[id] = type;
         layer_dicts[id] = layer;
-
-        if (type == "Data") {
-            data_dicts[id] = instances; // All data goes for all data layers. May be should be splitted by them
-            dataIds_.push_back(id);
-        }
-        if (type == "Target") {
-            data_dicts[id] = answers;
-        }
     }
 }
 
 void Graph::GetEdges(const crow::json::rvalue& connections,
-              std::unordered_map<int, std::vector<int>>& straightEdges,
-              std::unordered_map<int, std::vector<int>>& reversedEdges,
-              std::unordered_set<int>& entryNodes) {
+                     std::unordered_map<int, std::vector<int>>& straightEdges,
+                     std::unordered_map<int, std::vector<int>>& reversedEdges,
+                     std::unordered_set<int>& entryNodes) {
     std::unordered_set<int> nodesWithParents;
     for (auto& connection : connections) {
         if (!connection.has("layer_from") || !connection.has("layer_to")) {
@@ -56,8 +43,8 @@ void Graph::GetEdges(const crow::json::rvalue& connections,
 }
 
 void Graph::TopologySort(std::unordered_map<int, std::vector<int>>& edges,
-                  std::unordered_set<int>& entryNodes,
-                  std::vector<int>& layersOrder) {
+                         std::unordered_set<int>& entryNodes,
+                         std::vector<int>& layersOrder) {
     std::unordered_set<int> closed;
     std::stack<int> dfsStack;
     bool isFinal;
@@ -88,9 +75,9 @@ void Graph::TopologySort(std::unordered_map<int, std::vector<int>>& edges,
 }
 
 void Graph::Initialize(crow::json::rvalue modelJson,
-             const std::vector<std::vector<float>>& data,
-             RandomObject* randomInit,
-             OptimizerBase& SGD) {
+                       RandomObject* randomInit,
+                       OptimizerBase& SGD,
+                       size_t batch_size) {
     Allocator::startVirtualMode();
     CHECK_HAS_FIELD(modelJson, "graph");
     CHECK_HAS_FIELD(modelJson["graph"], "layers");
@@ -101,8 +88,7 @@ void Graph::Initialize(crow::json::rvalue modelJson,
 
     // Parse Jsons into dicts of Jsons
     std::unordered_map<int, crow::json::rvalue> layerDicts;
-    std::unordered_map<int, std::vector<float>> dataDicts;
-    OverviewLayers(layersJson, data, layerDicts, dataDicts);
+    OverviewLayers(layersJson, layerDicts);
 
     std::unordered_map<int, std::vector<int>> straightEdges, reversedEdges;
     std::unordered_set<int> entryNodes;
@@ -126,13 +112,15 @@ void Graph::Initialize(crow::json::rvalue modelJson,
         } else if (type == "ReLU") {
             layers_.emplace(layer_id, new ReLULayer{prevLayers});
         } else if (type == "Data" || type == "Target") {
-            CHECK_HAS_FIELD(layerDicts[layer_id], "parameters");
-            auto params = ParseData2d(layerDicts[layer_id]["parameters"]);
-            if (dataDicts[layer_id].size() % params.width != 0) {
-                throw std::invalid_argument("Sizes mismatch!");
+            if (type == "Data") {
+                dataIds_.push_back(layer_id);
             }
-            params.height = dataDicts[layer_id].size() / params.width;
-            layers_.emplace(layer_id, new Data2dLayer{params, dataDicts[layer_id]});
+            if (type == "Target") {
+                targetsIds_.push_back(layer_id);
+            }
+            CHECK_HAS_FIELD(layerDicts[layer_id], "parameters");
+            Shape shape = ParseData(layerDicts[layer_id]["parameters"]);
+            layers_.emplace(layer_id, new DataLayer{shape, batch_size});
         } else if (type == "Output") {
             for (auto prevLayerId : reversedEdges[layer_id]) {
                 lastPredictIds_.push_back(prevLayerId);
@@ -146,18 +134,28 @@ void Graph::Initialize(crow::json::rvalue modelJson,
     }
 }
 
-void Graph::ChangeInputData(std::vector<float> data) {
+void Graph::ChangeLayersData(std::vector<float> data, BaseLayerType type) {
     // All data goes to every data layer. Should be changed?
-    for (int id : dataIds_) {
-        Data2dLayer* layer = reinterpret_cast<Data2dLayer*>(layers_[id]);
+    std::vector<int>* layers = nullptr;
+    if (type == BaseLayerType::Data) {
+        layers = &dataIds_;
+    } else if (type == BaseLayerType::Targets) {
+        layers = &targetsIds_;
+    } else {
+        throw std::invalid_argument("Can change data only in 'Data' or 'Target' layers");
+    }
+    for (int id : *layers) {
+        DataLayer* layer = reinterpret_cast<DataLayer*>(layers_[id]);
 
-        size_t width = layer->result->output->shape.cols();
-        if (data.size() % width != 0) {
+        Shape expected_shape = layer->result->output->shape;
+        size_t sample_size = expected_shape.stride(4 - expected_shape.dimsCount);
+
+        if (data.size() % sample_size != 0 || data.size() > expected_shape.size()) {
+            std::cerr << data.size() << " " << sample_size << " " << expected_shape.size() << std::endl;
             throw std::invalid_argument("Sizes mismatch!");
         }
-        Shape expectedShape = layer->result->output->shape;
-        data.resize(expectedShape.size(), 0);
-        layer->result->output.emplace(Blob::constBlob(expectedShape, data.data()));
+        data.resize(expected_shape.size(), 0);
+        layer->result->output.emplace(Blob::constBlob(expected_shape, data.data()));
     }
 }
 
@@ -168,23 +166,26 @@ Graph::~Graph() {
     Allocator::end();
 }
 
-std::vector<Layer*> Graph::getLastTrainLayers() const {
+std::vector<Layer*> Graph::getLayers(BaseLayerType type) const {
     std::vector<Layer*> result;
-    result.reserve(lastTrainIds_.size());
-    for (int id : lastTrainIds_) {
-        result.push_back(layers_.at(id));
+    std::vector<int>* layers_ids = nullptr;
+    if (type == BaseLayerType::Data) {
+        layers_ids = const_cast<std::vector<int>*>(&dataIds_);
+    } else if (type == BaseLayerType::Targets) {
+        layers_ids = const_cast<std::vector<int>*>(&targetsIds_);
+    } else if (type == BaseLayerType::TrainOut) {
+        layers_ids = const_cast<std::vector<int>*>(&lastTrainIds_);
+    } else {
+        layers_ids = const_cast<std::vector<int>*>(&lastPredictIds_);
     }
-    return result;
-}
 
-std::vector<Layer*> Graph::getLastPredictLayers() const {
-    std::vector<Layer*> result;
-    result.reserve(lastPredictIds_.size());
-    for (int id : lastPredictIds_) {
+    result.reserve(layers_ids->size());
+    for (int id : *layers_ids) {
         result.push_back(layers_.at(id));
     }
     return result;
 }
+
 const Layer& Graph::operator[](int i) const {
     return *layers_.at(i);
 }
diff --git a/server/api/GraphBuilder.h b/server/api/GraphBuilder.h
index 76a8bcf2..cbdca510 100644
--- a/server/api/GraphBuilder.h
+++ b/server/api/GraphBuilder.h
@@ -1,10 +1,20 @@
 #include <set>
 #include <vector>
+#include <string>
 
 #include <crow_all.h>
 #include "Parser.h"
 #include "Layer.h"
 
+
+enum class BaseLayerType : int {
+    Data       = 0,
+    Targets    = 1,
+    TrainOut   = 2,
+    PredictOut = 3,
+};
+
+
 class Graph {
 private:
     std::unordered_map<int, Layer*> layers_ = {};
@@ -12,18 +22,18 @@ class Graph {
     std::vector<int> lastTrainIds_ = {};
     std::vector<int> lastPredictIds_ = {};
     std::vector<int> dataIds_ = {};
+    std::vector<int> targetsIds_ = {};
 
 public:
     Graph() = default;
     void Initialize(crow::json::rvalue modelJson,
-          const std::vector<std::vector<float>>& data,
-          RandomObject* randomInit,
-          OptimizerBase& SGD);
+                    RandomObject* randomInit,
+                    OptimizerBase& SGD,
+                    size_t batch_size);
     ~Graph();
 
-    void OverviewLayers(const crow::json::rvalue& layers, const std::vector<std::vector<float>>& data,
-                        std::unordered_map<int, crow::json::rvalue>& layer_dicts,
-                        std::unordered_map<int, std::vector<float>>& data_dicts);
+    void OverviewLayers(const crow::json::rvalue& layers,
+                        std::unordered_map<int, crow::json::rvalue>& layer_dicts);
 
     void GetEdges(const crow::json::rvalue& connections,
                   std::unordered_map<int, std::vector<int>>& straightEdges,
@@ -34,10 +44,9 @@ class Graph {
                       std::unordered_set<int>& entryNodes,
                       std::vector<int>& layersOrder);
 
-    void ChangeInputData(std::vector<float> data);
+    void ChangeLayersData(std::vector<float> data, BaseLayerType type);
     
-    std::vector<Layer*> getLastTrainLayers() const;
-    std::vector<Layer*> getLastPredictLayers() const;
+    std::vector<Layer*> getLayers(BaseLayerType type) const;
 
     const Layer& operator[](int i) const;
 };
diff --git a/server/api/Parser.cpp b/server/api/Parser.cpp
index e1496665..4462f529 100644
--- a/server/api/Parser.cpp
+++ b/server/api/Parser.cpp
@@ -6,15 +6,14 @@ void CHECK_HAS_FIELD(const crow::json::rvalue& layer, const std::string& field)
     }
 }
 
-void ParseCsvData(const std::vector<std::vector<float>>& data, std::vector<float>& instances, std::vector<float>& answers) {
-    // Think about optimization via reservation
-    for (auto& instance : data) {
-        answers.push_back(instance.back());
-        for (int i = 0; i < instance.size() - 1; ++i) {
-            instances.push_back(instance[i]);
-        }
-    }
-}
+// void ParseCsvData(const std::vector<std::vector<float>>& data, std::vector<float>& instances, std::vector<float>& answers) {
+//     instances.reserve(data.size());
+//     answers.reserve(data.size());
+//     for (auto& instance : data) {
+//         answers.push_back(instance.back());
+//         instances.emplace_back(instance.begin(), std::prev(instance.end()));
+//     }
+// }
 
 LinearLayerParameters ParseLinear(const crow::json::rvalue& parameters) {
     size_t inFeatures, outFeatures;
@@ -26,18 +25,23 @@ LinearLayerParameters ParseLinear(const crow::json::rvalue& parameters) {
     inFeatures = static_cast<size_t>(parameters["inFeatures"].i());
     outFeatures = static_cast<size_t>(parameters["outFeatures"].i());
 
-    if (parameters.has("bias")) {
-        bias = parameters["bias"].b();
-    }
+    // if (parameters.has("bias")) {
+    //     std::cout << parameters["bias"] << std::endl;
+    //     bias = parameters["bias"].b();
+    //     std::cout << "done" << std::endl;
+    // }
 
     return LinearLayerParameters{inFeatures, outFeatures, bias};
 }
 
-Data2dLayerParameters ParseData2d(const crow::json::rvalue& parameters) {
-    size_t width;
+Shape ParseData(const crow::json::rvalue& parameters) {
+    std::vector<size_t> shape;
+    shape.reserve(3);
 
-    CHECK_HAS_FIELD(parameters, "width");
+    CHECK_HAS_FIELD(parameters, "shape");
 
-    width = static_cast<size_t>(parameters["width"].i());
-    return Data2dLayerParameters{.width = width};
+    for (auto dim : parameters["shape"]) {
+        shape.push_back(dim.i());
+    }
+    return Shape{std::move(shape)};
 }
diff --git a/server/api/Parser.h b/server/api/Parser.h
index 23662921..a742689c 100644
--- a/server/api/Parser.h
+++ b/server/api/Parser.h
@@ -18,7 +18,7 @@
 
 void CHECK_HAS_FIELD(const crow::json::rvalue& layer, const std::string& field);
 
-void ParseCsvData(const std::vector<std::vector<float>>& data, std::vector<float>& instances, std::vector<float>& answers);
+// void ParseCsvData(const std::vector<std::vector<float>>& data, std::vector<float>& instances, std::vector<float>& answers);
 
 LinearLayerParameters ParseLinear(const crow::json::rvalue& parameters);
-Data2dLayerParameters ParseData2d(const crow::json::rvalue& parameters);
+Shape ParseData(const crow::json::rvalue& parameters);
diff --git a/server/api/server.cpp b/server/api/server.cpp
index 151044ca..69387277 100644
--- a/server/api/server.cpp
+++ b/server/api/server.cpp
@@ -2,65 +2,167 @@
 #include <fstream>
 #include <vector>
 #include <string>
+#include <sstream>
+
+#include <filesystem>
 
 #include <crow_all.h>
+
+
+#include <cpprest/http_client.h>
+#include <cpprest/filestream.h>
+#include <cpprest/uri.h>
+#include <cpprest/json.h>
+
+#pragma push_macro("U")
+#undef U
+#include "ImageLoader.h"
+#pragma pop_macro("U")
+
 #include "GraphBuilder.h"
 #include "CsvLoader.h"
+#include "DataMarker.h"
+#include <zip.h>
 
 using namespace std;
 using namespace crow;
 
 std::string getDataPath(int id) {
-    return "./model_data/data/" + std::to_string(id) + ".csv";
+    return "./model_data/data/" + std::to_string(id);
 }
 
 std::string getPredictPath(int id) {
-    return "./model_data/predict/" + std::to_string(id) + ".csv";
+    return "./model_data/predict/" + std::to_string(id);
 }
 
-void train(json::rvalue& json, Graph** graph, int model_id) {
+void GetLogs(const Blob& node, std::vector<web::json::value>& values) {
+    assert(node.shape.dimsCount <= 2);
+    values.reserve(values.size() + node.shape.size());
+    for (size_t sample_index = 0; sample_index < node.shape.rows(); ++sample_index) {
+        for (size_t feature_index = 0; feature_index < node.shape.cols(); ++feature_index) {
+            values.push_back(web::json::value::number(node(0, 0, sample_index, feature_index)));
+        }
+    }
+}
+
+void train(json::rvalue& json, Graph** graph, int model_id, int user_id, FileExtension extension) {
     RandomObject initObject(0, 1, 42);
     OptimizerBase SGD = OptimizerBase(0.1);
-    std::vector<std::vector<float>> data = CsvLoader::load_csv(getDataPath(model_id));
+
+    // Should be adopted for DataLoader possibilities
+    std::string path = getDataPath(model_id);
+    if (extension == FileExtension::Csv) {
+        path += "/1.csv";
+    }
+    DataMarker dataMarker = DataMarker(path, extension, 100, 4);
+    DataLoader dataLoader = dataMarker.get_train_loader();
+
+    size_t batch_size = 4;  // hard-coded
     *graph = new Graph();
-    (*graph)->Initialize(json, data, &initObject, SGD);
+    (*graph)->Initialize(json, &initObject, SGD, batch_size);
     std::cout << "Graph is ready!" << std::endl;
 
-    auto& lastNode = (*graph)->getLastTrainLayers()[0]->result.value();  // Пока не думаем о нескольких выходах (!) Hard-coded
+    auto& lastTrainNode = (*graph)->getLayers(BaseLayerType::TrainOut)[0]->result.value();
 
-    lastNode.forward();
-    lastNode.gradient = Blob::ones({{1}});
-    lastNode.backward();
+    lastTrainNode.forward();
+    lastTrainNode.gradient = Blob::ones({{1}});
+    lastTrainNode.backward();
     Allocator::endSession();
-    lastNode.clear();
+    lastTrainNode.clear();
     Allocator::endVirtualMode();
 
-    for (int j = 0; j < 1000; ++j) {
-        auto& result = lastNode.forward();
-        printf("%d: %f\n", j, result(0, 0, 0, 0));
-        // lastNode.gradient = result;
-        lastNode.gradient = Blob::ones({{1}});
-        lastNode.backward();
-        SGD.step();
-        lastNode.clear();
+    size_t buffer_size = 5, actual_size = 0;
+    web::json::value request;
+    request[U("rewrite")] = web::json::value::boolean(true);
+    std::vector<web::json::value> targets, outputs;
+
+    size_t max_epochs = 30;
+    std::pair<std::vector<float>, std::vector<float>> batch;
+
+    web::http::client::http_client client(U("http://localhost:3000"));
+    std::ostringstream request_url;
+    request_url << "/update_metrics/" << user_id << "/" << model_id;
+
+    auto& lastPredictNode = (*graph)->getLayers(BaseLayerType::PredictOut)[0]->result.value().output;
+    auto& targetsNode = (*graph)->getLayers(BaseLayerType::Targets)[0]->result.value().output;
+    for (size_t epoch = 0; epoch < max_epochs; ++epoch) {
+        for (size_t batch_index = 0; batch_index < dataLoader.batch_count(); ++batch_index) {
+            batch = dataLoader.get_raw(batch_index);
+            (*graph)->ChangeLayersData(batch.first, BaseLayerType::Data);
+            (*graph)->ChangeLayersData(batch.second, BaseLayerType::Targets);
+
+            lastTrainNode.forward();
+
+            GetLogs(lastPredictNode.value(), targets);
+            GetLogs(targetsNode.value(), outputs);
+
+            lastTrainNode.gradient = Blob::ones({{1}});
+            lastTrainNode.backward();
+            SGD.step();
+            Allocator::endSession();
+            lastTrainNode.clear();
+        }
+
+        request[U("targets")][actual_size] = web::json::value::array(targets);
+        request[U("outputs")][actual_size] = web::json::value::array(outputs);
+        targets.clear();
+        outputs.clear();
+        ++actual_size;
+
+        if ((epoch == max_epochs - 1 && actual_size > 0) ||
+            actual_size == buffer_size) {
+            request[U("label")] = web::json::value::string("train");
+            client.request(web::http::methods::PUT, U(request_url.str()), request);
+            request = web::json::value();
+            actual_size = 0;
+        }
     }
 }
 
-void predict(int model_id, Graph* graph, std::vector<float>& answer) {
-    std::vector<std::vector<float>> predict_data = CsvLoader::load_csv(getPredictPath(model_id));
-    graph->ChangeInputData(predict_data[0]);
+void predict(int model_id, Graph* graph, std::vector<float>& answer, FileExtension extension) {
+    std::vector<std::vector<float>> predict_data;
+    if (extension == FileExtension::Csv) {
+        predict_data = CsvLoader::load_csv(getPredictPath(model_id) + "/1.csv");
+    }
+    else {
+        predict_data = {ImageLoader::load_image((getPredictPath(model_id) + "/1.png").c_str())};
+    }
+    graph->ChangeLayersData(predict_data[0], BaseLayerType::Data);
 
-    auto& lastNode = graph->getLastPredictLayers()[0]->result.value();  // Пока не думаем о нескольких выходах (!) Hard-coded
+    // Пока не думаем о нескольких выходах (!) Hard-coded
+    auto& lastNode = graph->getLayers(BaseLayerType::PredictOut)[0]->result.value();
     lastNode.clear();
-    const Blob& result = lastNode.forward();
+    lastNode.forward();
+
+    auto& result = lastNode.output.value();
+    assert(result.shape.dimsCount == 2);
+
+    answer.reserve(result.shape.cols());
+    for (size_t i = 0; i < result.shape.cols(); ++i) {
+        answer.push_back(result(0, i));
+        std::cout << result(0, i) << std::endl;
+    }
+}
 
-    answer.reserve(result.shape.rows() * result.shape.cols());
-    for (size_t j = 0; j < result.shape.rows(); ++j) {
-        for (size_t i = 0; i < result.shape.cols(); ++i) {
-            answer.push_back(result(j, i));
-            std::cout << result(j, i) << std::endl;
+void extract_from_zip(std::string path, std::string root) {
+    zip_t* z;
+    int err;
+    z = zip_open(path.c_str(), 0, &err);
+    if (z == nullptr) {
+        throw std::runtime_error("File doesn't exist");
+    }
+    zip_stat_t info;
+    for (int i = 0; i < zip_get_num_files(z); ++i) {
+        if (zip_stat_index(z, i, 0, &info) == 0) {
+            ofstream fout(root + "/" + info.name, ios::binary);
+            zip_file* file = zip_fopen_index(z, i, 0);
+            std::vector<char> file_data(info.size);
+            zip_fread(file, file_data.data(), info.size);
+            fout.write(file_data.data(), info.size);
+            fout.close();
         }
     }
+    std::filesystem::remove(path);
 }
 
 void invalidArgs() { 
@@ -73,25 +175,24 @@ int main(int argc, char *argv[]) {
     SimpleApp app;
 
     std::map<int, Graph*> sessions;
+    std::map<int, FileExtension> file_types;
 
-    CROW_ROUTE(app, "/predict/<int>").methods(HTTPMethod::POST)
+    CROW_ROUTE(app, "/predict/<int>").methods(HTTPMethod::PUT)
     ([&](const request& req, int model_id) -> response {
         if (sessions.find(model_id) == sessions.end()) return response(status::METHOD_NOT_ALLOWED, "Not trained");
         std::vector<float> answer;
         try {
-            predict(model_id, sessions[model_id], answer);
+            predict(model_id, sessions[model_id], answer, file_types[model_id]);
         } catch (const std::runtime_error &err) {
+            std::cout << err.what() << std::endl;
             return response(status::BAD_REQUEST, "Invalid body");
         }
-        json::wvalue response;
-        for (int i = 0; i < answer.size(); ++i) {
-            response[i] = answer[i];
-        }
+        json::wvalue response = answer[0];
         return crow::response(status::OK, response);
     });
 
-    CROW_ROUTE(app, "/train/<int>").methods(HTTPMethod::POST)
-    ([&](const request& req, int model_id) -> response {
+    CROW_ROUTE(app, "/train/<int>/<int>").methods(HTTPMethod::POST)
+    ([&](const request& req, int user_id, int model_id) -> response {
         auto body = json::load(req.body);
         std::cout << "Checking json!" << std::endl;
         if (!body) return response(status::BAD_REQUEST, "Invalid body");
@@ -100,22 +201,42 @@ int main(int argc, char *argv[]) {
             delete sessions[model_id];
         }
         Graph* g = nullptr;
-        train(body, &g, model_id);
+
+        train(body, &g, model_id, user_id, file_types[model_id]);
         sessions[model_id] = g;
         return response(status::OK, "done");
     });
 
-    //curl -X POST -F "InputFile=@filename" http://0.0.0.0:2000/upload_data/1/0 (last can be 1)
-    CROW_ROUTE(app, "/upload_data/<int>/<int>").methods(HTTPMethod::Post)
-    ([&](const request& req, int model_id, int type) -> response {
+    // curl -X POST -F "InputFile=@filename" http://0.0.0.0:2000/upload_data/1/0/0
+    // Second argument is for request type (train or predict), third - for file type (csv or zip)
+    CROW_ROUTE(app, "/upload_data/<int>/<int>/<int>").methods(HTTPMethod::Post)
+    ([&](const request& req, int model_id, int type, int file_type) -> response {
         crow::multipart::message file_message(req);
-        std::string path;
+        std::string path, root;
         if (type == 0) {
             path = getDataPath(model_id);
         }
         else {
             path = getPredictPath(model_id);
         }
+        root = path;
+        if (std::filesystem::exists(path)) {
+            std::filesystem::remove_all(path);
+        }
+        std::filesystem::create_directory(path);
+        if (file_type == 0) {
+            path += "/1.csv";
+            file_types[model_id] = FileExtension::Csv;
+        }
+        else {
+            file_types[model_id] = FileExtension::Png;
+            if (type == 0) {
+                path += "/1.zip";
+            }
+            else {
+                path += "/1.png";
+            }
+        }
         std::ofstream out_file(path);
         if (!out_file) {
             return response(status::INTERNAL_SERVER_ERROR, "Failed to open file for storage");
@@ -126,6 +247,14 @@ int main(int argc, char *argv[]) {
         }
         out_file << (*content).second.body;
         out_file.close();
+        if (file_type != 0 && type == 0) {
+            try {
+                extract_from_zip(path, root);
+            }
+            catch (...) {
+                return response(status::INTERNAL_SERVER_ERROR, "Error in extracting from zip");
+            }
+        }
         return crow::response(status::OK, "done");
     });
 
diff --git a/server/core/Allocator.cpp b/server/core/Allocator.cpp
index 2ae4a83c..10ce9c8a 100644
--- a/server/core/Allocator.cpp
+++ b/server/core/Allocator.cpp
@@ -9,7 +9,7 @@ using namespace std;
 
 Allocator* Allocator::instance = NULL;
 
-#define TMP_BUFF_SIZE 2048
+#define TMP_BUFF_SIZE 16384
 
 void Allocator::startVirtualMode() {
     assert(!instance);
diff --git a/server/core/Layer.cpp b/server/core/Layer.cpp
index 7f143a42..a6a411c5 100644
--- a/server/core/Layer.cpp
+++ b/server/core/Layer.cpp
@@ -32,9 +32,16 @@ ReLULayer::ReLULayer(const std::vector<TensorRef>& args) {
     result = Tensor(relu, {args[0]});
 }
 
-Data2dLayer::Data2dLayer(const Data2dLayerParameters& params, const std::vector<float>& values)
-    : width(params.width) {
-    result = Tensor(Blob::constBlob({{params.height, width}}, values.data()));
+DataLayer::DataLayer(const Shape& shape, const std::vector<float>& values) {
+    result = Tensor(Blob::constBlob(shape, values.data()));
+}
+
+DataLayer::DataLayer(const Shape& shape, size_t batch_size) {
+    std::vector<size_t> dims = shape.getDims();
+    std::vector<size_t> new_dims(dims.end() - shape.dimsCount, dims.end());
+    new_dims.insert(new_dims.begin(), batch_size);
+    Shape batch_shape(new_dims);
+    result = Tensor(Blob::constRandomBlob(batch_shape, nullptr));
 }
 
 MSELoss::MSELoss(const std::vector<TensorRef>& args) : mean({0, 1, 2, 3}) {
diff --git a/server/core/Layer.h b/server/core/Layer.h
index 8d9cbb50..bdca7c95 100644
--- a/server/core/Layer.h
+++ b/server/core/Layer.h
@@ -5,6 +5,7 @@
 
 #include "RandomInit.h"
 #include "Tensor.h"
+#include "Shape.h"
 #include "Parameters.h"
 
 
@@ -16,10 +17,10 @@ class Layer {
     std::vector<TensorRef> layerOperationParams;
 };
 
-class Data2dLayer: public Layer {
+class DataLayer: public Layer {
 public:
-    size_t width;
-    Data2dLayer(const Data2dLayerParameters& params, const std::vector<float>& values);
+    DataLayer(const Shape& params, const std::vector<float>& values);
+    DataLayer(const Shape& params, size_t batch_size);
 };
 
 class LinearLayer: public Layer {
diff --git a/server/core/LazyBlob.cpp b/server/core/LazyBlob.cpp
index 3b6cd432..601cf675 100644
--- a/server/core/LazyBlob.cpp
+++ b/server/core/LazyBlob.cpp
@@ -388,7 +388,7 @@ const LazyBlob& operator / (const LazyBlob &a, float b) {
 Blob& operator += (Blob& a, const LazyBlob& b) {
     assert(a.shape == b.shape());
 
-    std::vector<size_t> size =  a.shape.getDims();
+    std::vector<size_t> size = a.shape.getDims();
     map(size, [&](size_t k, size_t l, size_t i, size_t j) {
        a(k, l, i, j) += b(k, l, i, j);
     });
@@ -398,7 +398,7 @@ Blob& operator += (Blob& a, const LazyBlob& b) {
 Blob& operator -= (Blob& a, const LazyBlob& b) {
     assert(a.shape == b.shape());
 
-    std::vector<size_t> size =  a.shape.getDims();
+    std::vector<size_t> size = a.shape.getDims();
     map(size, [&](size_t k, size_t l, size_t i, size_t j) {
        a(k, l, i, j) -= b(k, l, i, j);
     });
@@ -408,7 +408,7 @@ Blob& operator -= (Blob& a, const LazyBlob& b) {
 Blob& operator *= (Blob& a, const LazyBlob& b) {
     assert(a.shape == b.shape());
 
-    std::vector<size_t> size =  a.shape.getDims();
+    std::vector<size_t> size = a.shape.getDims();
     map(size, [&](size_t k, size_t l, size_t i, size_t j) {
        a(k, l, i, j) *= b(k, l, i, j);
     });
diff --git a/server/core/Operation.h b/server/core/Operation.h
index ad8b6e79..f178506d 100644
--- a/server/core/Operation.h
+++ b/server/core/Operation.h
@@ -14,6 +14,11 @@ struct Operation {
     virtual std::vector<LazyBlobRef> grad(const Blob& gradient, const std::vector<LazyBlobRef>& args) const = 0;
     virtual Shape computeDim(const std::vector<LazyBlobRef>& args) const = 0;
     const Operation& operator=(const Operation& other) const;
+    std::string name = "";
+
+    virtual std::string getName() const {
+        return name;
+    }
 };
 
 struct Noop: Operation {
diff --git a/server/core/Optimizer.cpp b/server/core/Optimizer.cpp
index 213f5745..7c57eafe 100644
--- a/server/core/Optimizer.cpp
+++ b/server/core/Optimizer.cpp
@@ -5,13 +5,18 @@
 #include "Tensor.h"
 #include "Optimizer.h"
 
+OptimizerBase::OptimizerBase(float lr) : lr(lr) {
+}
+
 void OptimizerBase::append(std::vector<TensorRef>& newParams) {
-    params.reserve(params.size() + newParams.size() * sizeof(TensorRef));
-    params.insert(params.end(),newParams.begin(),newParams.end());
+    params.reserve(params.size() + newParams.size());
+    params.insert(params.end(), newParams.begin(), newParams.end());
 }
 
 void OptimizerBase::step() {
     for (int i = 0; i < params.size(); i++) {
-        *params[i].get().output -= lr * *params[i].get().gradient;
+        if (params[i].get().gradient.has_value() && params[i].get().output.has_value()) {
+            params[i].get().output.value() -= lr * params[i].get().gradient.value();
+        }
     }
 }
\ No newline at end of file
diff --git a/server/core/Optimizer.h b/server/core/Optimizer.h
index f5cb0e75..50843a79 100644
--- a/server/core/Optimizer.h
+++ b/server/core/Optimizer.h
@@ -5,12 +5,12 @@
 #include "Tensor.h"
 
 class OptimizerBase {
-
-const float lr;
-std::vector<TensorRef> params;
-
 public:
-    OptimizerBase(float lr) : lr(lr), params() {};
+    OptimizerBase(float lr);
     void append(std::vector<TensorRef>& newParams);
     void step();
-};
\ No newline at end of file
+
+private:
+    const float lr;
+    std::vector<TensorRef> params;
+};
diff --git a/server/core/Parameters.h b/server/core/Parameters.h
index bb20cc20..27fce33a 100644
--- a/server/core/Parameters.h
+++ b/server/core/Parameters.h
@@ -5,8 +5,3 @@ struct LinearLayerParameters {
     std::size_t outFeatures;
     bool bias;
 };
-
-struct Data2dLayerParameters {
-    std::size_t width;
-    std::size_t height;
-};
diff --git a/server/tests/linear_relu_linear_mse.json b/server/tests/linear_relu_linear_mse.json
index f1d872ac..f89468be 100644
--- a/server/tests/linear_relu_linear_mse.json
+++ b/server/tests/linear_relu_linear_mse.json
@@ -31,7 +31,7 @@
                 "id": 0,
                 "type": "Data",
                 "parameters": {
-                    "width": 2
+                    "shape": [2]
                 }
             },
             {
@@ -60,7 +60,7 @@
                 "id": 4,
                 "type": "Target",
                 "parameters": {
-                    "width": 1
+                    "shape": [1]
                 }
             },
             {

From dad95f8ec7055eb6b37f31e69ea3e875d78eb719 Mon Sep 17 00:00:00 2001
From: lpetrov02 <lpetrov02@mail.ru>
Date: Tue, 19 Dec 2023 10:12:37 +0300
Subject: [PATCH 2/6] Follow up review

---
 server/core/Allocator.cpp | 2 +-
 server/core/Operation.h   | 5 -----
 2 files changed, 1 insertion(+), 6 deletions(-)

diff --git a/server/core/Allocator.cpp b/server/core/Allocator.cpp
index 10ce9c8a..faa6fa29 100644
--- a/server/core/Allocator.cpp
+++ b/server/core/Allocator.cpp
@@ -9,7 +9,7 @@ using namespace std;
 
 Allocator* Allocator::instance = NULL;
 
-#define TMP_BUFF_SIZE 16384
+#define TMP_BUFF_SIZE 4096
 
 void Allocator::startVirtualMode() {
     assert(!instance);
diff --git a/server/core/Operation.h b/server/core/Operation.h
index f178506d..ad8b6e79 100644
--- a/server/core/Operation.h
+++ b/server/core/Operation.h
@@ -14,11 +14,6 @@ struct Operation {
     virtual std::vector<LazyBlobRef> grad(const Blob& gradient, const std::vector<LazyBlobRef>& args) const = 0;
     virtual Shape computeDim(const std::vector<LazyBlobRef>& args) const = 0;
     const Operation& operator=(const Operation& other) const;
-    std::string name = "";
-
-    virtual std::string getName() const {
-        return name;
-    }
 };
 
 struct Noop: Operation {

From 96dbd249552e8c8fda36499bb9c46a533640afb6 Mon Sep 17 00:00:00 2001
From: lpetrov02 <lpetrov02@mail.ru>
Date: Tue, 19 Dec 2023 12:37:32 +0300
Subject: [PATCH 3/6] Follow up review

---
 client/templates/main.html | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/client/templates/main.html b/client/templates/main.html
index 01a7dfd3..15250f5d 100644
--- a/client/templates/main.html
+++ b/client/templates/main.html
@@ -174,7 +174,7 @@ <h3></h3>
           </div>
         </div>
 
-        <div class="relu-layer-parameters" id="relu-layer-parameters" style="display: none">
+        <div class="relu-layer-parameters layer-parameters" id="relu-layer-parameters" style="display: none">
           <label for="relu-width-parameter">Width</label>
           <input id="relu-width-parameter" type="number" value="1" size="4" />
           <h3></h3>
@@ -227,7 +227,7 @@ <h3></h3>
           </div>
         </div>
 
-        <div class="loss-layer-parameters" id="loss-layer-parameters" style="display: none">
+        <div class="loss-layer-parameters layer-parameters" id="loss-layer-parameters" style="display: none">
           <label for="loss-width-parameter">Width</label>
           <input id="loss-width-parameter" type="number" value="1" size="4" />
           <h3></h3>
@@ -1381,7 +1381,7 @@ <h3></h3>
 
         // Input selection
         writeIdOnConnections(input_selection_layer_id)
-        let sortable_list = getSortableInputList(node.class)
+        let sortable_list = getSortableInputList(node)
         let child = sortable_list.lastElementChild
 
         while (child) {

From 813bc2c4a552f8599efa2ec538d0ae0ce1cd851e Mon Sep 17 00:00:00 2001
From: Artem Goldenberg <58527023+Artem-Goldenberg@users.noreply.github.com>
Date: Wed, 20 Dec 2023 01:41:36 +0300
Subject: [PATCH 4/6] ID-167: Upload zip (#74)

---
 .github/workflows/CI.yml               |   1 +
 .gitignore                             |   5 ++
 client/scripts/requests.js             | 102 +++++++++++++++++--------
 client/templates/main.html             |  34 +++------
 documentation/png-examples/Ours.png    | Bin 0 -> 68180 bytes
 documentation/png-examples/Vectors.png | Bin 0 -> 14345 bytes
 py_server/mlcraft/__init__.py          |   1 +
 py_server/mlcraft/dataset.py           |  48 ------------
 py_server/mlcraft/errors.py            |   2 +-
 py_server/mlcraft/server.py            |  42 ++++++----
 server/api/server.cpp                  |  58 +++++++-------
 11 files changed, 145 insertions(+), 148 deletions(-)
 create mode 100644 documentation/png-examples/Ours.png
 create mode 100644 documentation/png-examples/Vectors.png
 delete mode 100644 py_server/mlcraft/dataset.py

diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
index adea88ef..9554a42c 100644
--- a/.github/workflows/CI.yml
+++ b/.github/workflows/CI.yml
@@ -51,6 +51,7 @@ jobs:
           sudo apt install -y g++-11
           sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-11 90
           sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-11 90
+          sudo apt install libzip-dev
 
       - name: install-cpprest
         run: sudo apt install libcpprest-dev
diff --git a/.gitignore b/.gitignore
index 48b197a5..f966ca0c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,6 +1,10 @@
 Build/
 build/
 
+# Large-files
+zip-examples
+model_data
+
 # IDE
 .vscode
 .idea
@@ -10,6 +14,7 @@ build/
 .DS_Store
 .AppleDouble
 .LSOverride
+*.entitlements
 
 # Javascript
 package-lock.json
diff --git a/client/scripts/requests.js b/client/scripts/requests.js
index 35124124..c8049021 100644
--- a/client/scripts/requests.js
+++ b/client/scripts/requests.js
@@ -124,29 +124,60 @@ async function deleteConnection(sending_object) {
     return response
 }
 
-function trainRequest() {
-    if (!train_data) {
-        errorNotification("No training data was set.")
-    } else {
-        fetch(`http://${py_server_address}/train/${user_id}/${model_id}/0`, {
-            method: "PUT",
-            mode: "cors",
-            headers: {"Content-Type": "text/csv"},
-            body: train_data,
-        }).then(response => {
-            showBuildNotification(response.ok)
-            onTrainShowPredict(response.ok)
-            if (response.ok) {
-                setModelView("success")
-            } else {
-                setModelView("error")
-            }
+function uploadRequest() {
+    if (data_upload.files.length == 0) return
+    const file = data_upload.files[0]
+
+    fetch(`http://${py_server_address}/${user_id}/${model_id}`, {
+        method: "PATCH",
+        mode: "cors",
+        body: file,
+    }).then(response => {
+        if (!response.ok) {
+            Swal.fire({
+                position: "top-end",
+                icon: "error",
+                title: "Failed to upload data",
+                showConfirmButton: false,
+                timer: 1500,
+            })
+            console.error(`Failed to upload data for ${file.name}`)
+            return
+        }
+        Swal.fire({
+            position: "top-end",
+            icon: "success",
+            title: "Successfully uploaded",
+            showConfirmButton: false,
+            timer: 1500,
         })
-    }
+    })
+    setModelView("irrelevant")
+    // allow user to press a train button from now on
+    button_wrapper = document.getElementById("train-button")
+    button_wrapper.getElementsByTy
+    train_button = button_wrapper.children[0]
+    button_wrapper.removeAttribute("disabled")
+    train_button.removeAttribute("disabled")
+}
+
+function trainRequest() {
+    fetch(`http://${py_server_address}/train/${user_id}/${model_id}/0`, {
+        method: "PUT",
+        mode: "cors",
+    }).then(response => {
+        showBuildNotification(response.ok)
+        onTrainShowPredict(response.ok)
+        if (response.ok) {
+            setModelView("success")
+        } else {
+            setModelView("error")
+        }
+    })
 }
 
 async function predictRequest() {
-    if (csv_predict.files.length == 0) {
+    if (predict_button.files.length == 0) {
         errorNotification("Empty predict file.")
         return
     }
@@ -159,25 +190,34 @@ async function predictRequest() {
             showConfirmButton: true,
         })
     }
-    const file = csv_predict.files[0]
-    const text = await file.text()
-    const response = await fetch(
+    const file = predict_button.files[0]
+    let response = await fetch(
         `http://${py_server_address}/predict/${user_id}/${model_id}`,
         {
             method: "PUT",
             mode: "cors",
-            headers: {"Content-Type": "text/csv"},
-            body: text,
+            body: file,
         },
     )
+    if (!response.ok) {
+        Swal.fire("Error!", "Failed to upload the png image", "error")
+        console.error(
+            `Failed to upload the png with ${response.statusText}: ${responseJson.error}`,
+        )
+        return
+    }
+    response = await fetch(
+        `http://${py_server_address}/predict/${user_id}/${model_id}`,
+        {method: "GET", mode: "cors"},
+    )
     const responseJson = await response.json()
-    hideResult() // hide previous predict result
-    if (response.ok) onPredictShowResult(responseJson)
-    else {
-        Swal.fire("Error!", "Server is not responding now.", "error")
-        errorNotification("Failed to predict.\n" + responseJson.error)
-        console.log(
-            `Predict failed with ${response.statusText}: ${responseJson.error}`,
+    if (!response.ok) {
+        Swal.fire("Error!", "Failed to predict", "error")
+        console.error(
+            `Failed to predict with with ${response.statusText}: ${responseJson.error}`,
         )
+        return
     }
+    hideResult() // hide previous predict result
+    onPredictShowResult(responseJson)
 }
diff --git a/client/templates/main.html b/client/templates/main.html
index 15250f5d..86db4342 100644
--- a/client/templates/main.html
+++ b/client/templates/main.html
@@ -113,7 +113,7 @@ <h2 onmousedown="return false">MLCraft</h2>
 
         <label class="button-wrapper">
           Upload
-          <input type="file" id="csv-upload-button" accept=".csv" />
+          <input type="file" id="dataset-upload-button" accept=".csv,.zip" />
         </label>
 
         <label class="button-wrapper" id="train-button" disabled>
@@ -123,7 +123,7 @@ <h2 onmousedown="return false">MLCraft</h2>
 
         <label class="button-wrapper" disabled>
           Predict
-          <input type="file" accept=".csv" id="csv-predict-button" disabled />
+          <input type="file" accept=".png" id="predict-button" disabled />
         </label>
         <div class="predict-result-wrapper" id="predict-result-wrapper">
           <output class="form-control-res" id="res-value-out" name="res-value" for="x-value y-value"></output>
@@ -1082,12 +1082,12 @@ <h3></h3>
 
     <!--JSON requests handling-->
     <script>
-      const csv_predict = document.getElementById("csv-predict-button")
-      csv_predict.onclick = () => {
-        csv_predict.value = null
+      const predict_button = document.getElementById("predict-button")
+      predict_button.onclick = () => {
+        predict_button.value = null
       }
 
-      csv_predict.addEventListener("input", predictRequest)
+      predict_button.addEventListener("input", predictRequest)
 
       function buildJsonFormData(form) {
         const jsonFormData = {}
@@ -1251,26 +1251,14 @@ <h3></h3>
       const showBuildNotification = build_status => {
         build_status ? buildSuccessful() : buildUnsuccessful()
       }
-      async function csvUploaded() {
-        if (csv_upload.files.length == 0) return
-        const file = csv_upload.files[0]
-        const text = await file.text()
-        // do whatever with the `text`
-        setModelView("irrelevant")
-        console.log(`Got goods: ${text}`)
-        train_data = text
-        // allow user to press a train button from now on
-        button_wrapper = document.getElementById("train-button")
-        button_wrapper.getElementsByTy
-        train_button = button_wrapper.children[0]
-        button_wrapper.removeAttribute("disabled")
-        train_button.removeAttribute("disabled")
+      const data_upload = document.getElementById("dataset-upload-button")
+      data_upload.onclick = () => {
+        data_upload.value = null
       }
-      const csv_upload = document.getElementById("csv-upload-button")
-      csv_upload.addEventListener("change", csvUploaded)
+      data_upload.addEventListener("change", uploadRequest)
 
       function onTrainShowPredict(training_successful) {
-        const predict_button = document.getElementById("csv-predict-button")
+        const predict_button = document.getElementById("predict-button")
         hideResult() // hide result when new training results arrive
         if (training_successful) {
           predict_button.removeAttribute("disabled")
diff --git a/documentation/png-examples/Ours.png b/documentation/png-examples/Ours.png
new file mode 100644
index 0000000000000000000000000000000000000000..3e4a553c2728d819596a7749374fd6c868d1b08f
GIT binary patch
literal 68180
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
KD+<t8&HoSTu9x)y

literal 0
HcmV?d00001

diff --git a/documentation/png-examples/Vectors.png b/documentation/png-examples/Vectors.png
new file mode 100644
index 0000000000000000000000000000000000000000..6366e8861da802b061d3835230907f563bd38a34
GIT binary patch
literal 14345
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

literal 0
HcmV?d00001

diff --git a/py_server/mlcraft/__init__.py b/py_server/mlcraft/__init__.py
index 912740c6..2df1fdb3 100644
--- a/py_server/mlcraft/__init__.py
+++ b/py_server/mlcraft/__init__.py
@@ -63,6 +63,7 @@ def make_app(config=None):
     app.register_error_handler(KeyError, key_error)  # no json field
     app.register_error_handler(ValueError, value_error)  # json wrong type
     app.register_error_handler(HTTPException, http_error)
+    app.register_error_handler(TimeoutError, timeout_error)
     app.register_error_handler(ConnectTimeout, timeout_error)
     app.register_error_handler(ConnectionError, connection_error)
 
diff --git a/py_server/mlcraft/dataset.py b/py_server/mlcraft/dataset.py
deleted file mode 100644
index 5fe8bc99..00000000
--- a/py_server/mlcraft/dataset.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import csv
-import math
-
-from http import HTTPStatus
-from io import StringIO
-from .errors import Error
-
-
-def get_layer(type: str, model: dict) -> dict:
-    layer = next(filter(lambda l: l["type"] == type, model["layers"]), None)
-    if layer is None:
-        raise Error(f"No {type} block in model", HTTPStatus.PRECONDITION_FAILED)
-    return layer
-
-
-def extract_train_data(bytes: bytes, model: dict) -> dict:
-    data_layer = get_layer("Data", model)
-    target_layer = get_layer("Target", model)
-
-    reader = csv.reader(StringIO(bytes.decode()))
-
-    data: list[float] = []
-    target: list[float] = []
-    dims = list(map(int, data_layer["parameters"]["shape"]))
-    dims_total = math.prod(dims)
-    for row in reader:
-        if dims_total != len(row) - 1:  # columns = features + 1 for target
-            raise Error("Input csv column count doesn't match data's feature count")
-
-        data.extend(map(float, row[:-1]))
-        target.append(float(row[-1]))
-
-    return {data_layer["id"]: data, target_layer["id"]: target}
-
-
-def extract_predict_data(bytes: bytes, model: dict) -> dict:
-    data_layer = get_layer("Data", model)
-    reader = csv.reader(StringIO(bytes.decode()))
-    row = next(reader, None)
-
-    dims = list(map(int, data_layer["parameters"]["shape"]))
-    dims_total = math.prod(dims)
-    if row is None:
-        raise Error("Bad csv format")
-    if dims_total != len(row):  # predict request - one row with data only
-        raise Error("Input csv column count doesn't match data's feature count")
-
-    return {data_layer["id"]: list(map(float, row))}
diff --git a/py_server/mlcraft/errors.py b/py_server/mlcraft/errors.py
index f9e3575a..86b912ec 100644
--- a/py_server/mlcraft/errors.py
+++ b/py_server/mlcraft/errors.py
@@ -44,7 +44,7 @@ def http_error(e: HTTPException):
     return {"error": str(e)}, HTTPStatus.BAD_REQUEST
 
 
-def timeout_error(e: ConnectTimeout):
+def timeout_error(e: TimeoutError | ConnectTimeout):
     return {"error": "Request to c++ server timeout"}, HTTPStatus.INTERNAL_SERVER_ERROR
 
 
diff --git a/py_server/mlcraft/server.py b/py_server/mlcraft/server.py
index a650235d..2271bc1c 100644
--- a/py_server/mlcraft/server.py
+++ b/py_server/mlcraft/server.py
@@ -1,6 +1,3 @@
-from json import dumps
-from sqlite3 import IntegrityError
-import datetime
 import requests
 from http import HTTPStatus
 from flask import Blueprint, request, current_app, send_file
@@ -12,19 +9,21 @@
     is_valid_model,
     convert_model,
     plot_metrics,
-    delete_file,
 )
 from .check_dimensions import assert_dimensions_match
 
 from .errors import Error
 
 from .db import sql_worker
-from .dataset import extract_predict_data, extract_train_data
 
 
 app = Blueprint("make a better name", __name__)
 
 
+def cpp_url(method: str):
+    return current_app.config["CPP_SERVER"] + "/" + method
+
+
 @app.route("/user", methods=["POST"])
 def add_user():
     json_data = request.json
@@ -52,7 +51,7 @@ def add_model(user_id: int):
     return {"model_id": inserted_id}, HTTPStatus.CREATED
 
 
-@app.route("/<int:user_id>/<int:model_id>", methods=["GET", "PUT", "DELETE"])
+@app.route("/<int:user_id>/<int:model_id>", methods=["GET", "PUT", "PATCH", "DELETE"])
 def model(user_id: int, model_id: int):
     sql_worker.verify_access(user_id, model_id)
     match request.method:
@@ -63,6 +62,14 @@ def model(user_id: int, model_id: int):
             d: dict[str, str | None] = defaultdict(lambda: None, **request.json)  # type: ignore
             sql_worker.update_model(model_id, d["name"], d["raw"])
             return "", HTTPStatus.OK
+        case "PATCH":
+            response = requests.post(
+                cpp_url(f"upload_data/{model_id}/0"),
+                data=request.data,
+                headers={"Content-Type": request.content_type},
+                timeout=10,
+            )
+            return "", response.status_code
         case "DELETE":
             sql_worker.delete_model(model_id)
             return "", HTTPStatus.OK
@@ -166,7 +173,7 @@ def train_model(
     model = {"graph": model}
 
     response = requests.post(
-        current_app.config["CPP_SERVER"] + f"/train/{user_id}/{model_id}",
+        cpp_url(f"train/{user_id}/{model_id}"),
         json=model,
         timeout=3,
     )
@@ -175,20 +182,25 @@ def train_model(
     return response.text, response.status_code
 
 
-@app.route("/predict/<int:user_id>/<int:model_id>", methods=["PUT"])
+@app.route("/predict/<int:user_id>/<int:model_id>", methods=["GET", "PUT"])
 def predict(user_id: int, model_id: int):
+    """PUT method is for uploading the png, GET method is for receiving the result"""
     sql_worker.verify_access(user_id, model_id)
 
-    model = sql_worker.get_graph_elements(model_id)
-    convert_model_parameters(model)
-
     if not sql_worker.is_model_trained(model_id):
         raise Error("Not trained", HTTPStatus.PRECONDITION_FAILED)
 
-    response = requests.put(
-        current_app.config["CPP_SERVER"] + f"/predict/{model_id}",
-        timeout=3,
-    )
+    match request.method:
+        case "GET":
+            response = requests.put(
+                cpp_url(f"predict/{model_id}"),
+            )
+        case "PUT":
+            response = requests.post(
+                cpp_url(f"upload_data/{model_id}/1"),
+                data=request.data,
+                headers={"Content-Type": "image/png"},
+            )
 
     return response.text, response.status_code
 
diff --git a/server/api/server.cpp b/server/api/server.cpp
index 69387277..395fb8b1 100644
--- a/server/api/server.cpp
+++ b/server/api/server.cpp
@@ -4,11 +4,10 @@
 #include <string>
 #include <sstream>
 
+#include <zip.h>
 #include <filesystem>
-
 #include <crow_all.h>
 
-
 #include <cpprest/http_client.h>
 #include <cpprest/filestream.h>
 #include <cpprest/uri.h>
@@ -22,7 +21,6 @@
 #include "GraphBuilder.h"
 #include "CsvLoader.h"
 #include "DataMarker.h"
-#include <zip.h>
 
 using namespace std;
 using namespace crow;
@@ -152,17 +150,16 @@ void extract_from_zip(std::string path, std::string root) {
         throw std::runtime_error("File doesn't exist");
     }
     zip_stat_t info;
-    for (int i = 0; i < zip_get_num_files(z); ++i) {
+    for (int i = 0; i < zip_get_num_entries(z, ZIP_FL_UNCHANGED); ++i) {
         if (zip_stat_index(z, i, 0, &info) == 0) {
             ofstream fout(root + "/" + info.name, ios::binary);
             zip_file* file = zip_fopen_index(z, i, 0);
-            std::vector<char> file_data(info.size);
-            zip_fread(file, file_data.data(), info.size);
-            fout.write(file_data.data(), info.size);
-            fout.close();
+            char *file_data = new char[info.size];
+            zip_fread(file, file_data, info.size);
+            fout.write(file_data, info.size);
+            delete[] file_data;
         }
     }
-    std::filesystem::remove(path);
 }
 
 void invalidArgs() { 
@@ -177,8 +174,9 @@ int main(int argc, char *argv[]) {
     std::map<int, Graph*> sessions;
     std::map<int, FileExtension> file_types;
 
-    CROW_ROUTE(app, "/predict/<int>").methods(HTTPMethod::PUT)
+    CROW_ROUTE(app, "/predict/<int>").methods(HTTPMethod::GET)
     ([&](const request& req, int model_id) -> response {
+        (void)req;
         if (sessions.find(model_id) == sessions.end()) return response(status::METHOD_NOT_ALLOWED, "Not trained");
         std::vector<float> answer;
         try {
@@ -209,9 +207,11 @@ int main(int argc, char *argv[]) {
 
     // curl -X POST -F "InputFile=@filename" http://0.0.0.0:2000/upload_data/1/0/0
     // Second argument is for request type (train or predict), third - for file type (csv or zip)
-    CROW_ROUTE(app, "/upload_data/<int>/<int>/<int>").methods(HTTPMethod::Post)
-    ([&](const request& req, int model_id, int type, int file_type) -> response {
-        crow::multipart::message file_message(req);
+    CROW_ROUTE(app, "/upload_data/<int>/<int>").methods(HTTPMethod::Post)
+    ([&](const request& req, int model_id, int type) -> response {
+        string content_type = req.get_header_value("Content-Type");
+        if (content_type.empty()) return response(status::BAD_REQUEST, "No Content-Type header provided");
+
         std::string path, root;
         if (type == 0) {
             path = getDataPath(model_id);
@@ -220,34 +220,31 @@ int main(int argc, char *argv[]) {
             path = getPredictPath(model_id);
         }
         root = path;
+
         if (std::filesystem::exists(path)) {
             std::filesystem::remove_all(path);
         }
         std::filesystem::create_directory(path);
-        if (file_type == 0) {
+
+        if (content_type == "text/csv") {
             path += "/1.csv";
             file_types[model_id] = FileExtension::Csv;
         }
-        else {
+        else if (content_type == "application/zip") {
+            path += "/1.zip";
             file_types[model_id] = FileExtension::Png;
-            if (type == 0) {
-                path += "/1.zip";
-            }
-            else {
-                path += "/1.png";
-            }
+        } else if (content_type == "image/png") {
+            path += "/1.png";
+            file_types[model_id] = FileExtension::Png;
+        } else {
+            return response(status::BAD_REQUEST, "Invalid content type: " + content_type);
         }
+
         std::ofstream out_file(path);
-        if (!out_file) {
-            return response(status::INTERNAL_SERVER_ERROR, "Failed to open file for storage");
-        }
-        auto content = file_message.part_map.find("InputFile");
-        if (content == file_message.part_map.end()) {
-            return response(status::BAD_REQUEST, "No file provided");
-        }
-        out_file << (*content).second.body;
+        out_file << req.body;
         out_file.close();
-        if (file_type != 0 && type == 0) {
+
+        if (content_type == "application/zip" && type == 0) {
             try {
                 extract_from_zip(path, root);
             }
@@ -255,6 +252,7 @@ int main(int argc, char *argv[]) {
                 return response(status::INTERNAL_SERVER_ERROR, "Error in extracting from zip");
             }
         }
+
         return crow::response(status::OK, "done");
     });
 

From 5a564d6fab8e5139c3fdf0a4ce4a8daf7515a9dd Mon Sep 17 00:00:00 2001
From: lpetrov02 <lpetrov02@mail.ru>
Date: Wed, 20 Dec 2023 01:52:40 +0300
Subject: [PATCH 5/6] Fixes graph tests

---
 server/tests/GraphTests.cpp | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/server/tests/GraphTests.cpp b/server/tests/GraphTests.cpp
index 4e5f242d..a038ab0d 100644
--- a/server/tests/GraphTests.cpp
+++ b/server/tests/GraphTests.cpp
@@ -38,19 +38,13 @@ void CheckFullProcess(const std::string& json_path,
     //                     PARSE LAYERS IDS
     // #################################################################
     std::unordered_map<int, crow::json::rvalue> layerDicts;
-    std::unordered_map<int, std::vector<float>> dataDicts;
-    g.OverviewLayers(layersJson, data, layerDicts, dataDicts);
+    g.OverviewLayers(layersJson, layerDicts);
 
     CHECK(layerDicts.size() == layer_ids_expected.size());
     for (auto id : layer_ids_expected) {
         CHECK(layerDicts.find(id) != layerDicts.end());
     }
 
-    CHECK(dataDicts.size() == data_ids_expected.size());
-    for (auto id : data_ids_expected) {
-        CHECK(dataDicts.find(id) != dataDicts.end());
-    }
-
     // #################################################################
     //                         PARSE EDGES
     // #################################################################

From b7417a892de84be11e923d1096d1393922adfbfd Mon Sep 17 00:00:00 2001
From: lpetrov02 <lpetrov02@mail.ru>
Date: Wed, 20 Dec 2023 19:30:07 +0300
Subject: [PATCH 6/6] Fixes DataLayer

---
 server/core/Layer.cpp | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/server/core/Layer.cpp b/server/core/Layer.cpp
index a6a411c5..708f3526 100644
--- a/server/core/Layer.cpp
+++ b/server/core/Layer.cpp
@@ -38,10 +38,8 @@ DataLayer::DataLayer(const Shape& shape, const std::vector<float>& values) {
 
 DataLayer::DataLayer(const Shape& shape, size_t batch_size) {
     std::vector<size_t> dims = shape.getDims();
-    std::vector<size_t> new_dims(dims.end() - shape.dimsCount, dims.end());
-    new_dims.insert(new_dims.begin(), batch_size);
-    Shape batch_shape(new_dims);
-    result = Tensor(Blob::constRandomBlob(batch_shape, nullptr));
+    dims[0] = batch_size;
+    result = Tensor(Blob::constRandomBlob(Shape(std::move(dims)), nullptr));
 }
 
 MSELoss::MSELoss(const std::vector<TensorRef>& args) : mean({0, 1, 2, 3}) {