Commit 462b94cb authored by Zohreh MOSTAANI's avatar Zohreh MOSTAANI
Browse files

[general][doc] fixed the label for beat general to show correctly on the page....

[general][doc] fixed the label for beat general to show correctly on the page. Fixed the Algorithms to have sysytem instead of platform, and fixed labels and refrences in the file
parent 89b4a136
Pipeline #24395 passed with stages
in 5 minutes
......@@ -23,9 +23,9 @@
.. _beat-system-algorithms:
===========
Algorithms
===========
============
Algorithms
============
Algorithms are user-defined piece of software that run within the blocks of a
toolchain. An algorithm can read data on the input(s) of the block and write
......@@ -46,7 +46,7 @@ one data sample at a time and must immediately produce some output data.
Furthermore, the way the algorithm handle the data is highly configurable and
covers a huge range of possible scenarios.
:numref:`beat-core-overview-block` displays the relationship between a
:numref:`beat-system-overview-block` displays the relationship between a
processing block and its algorithm.
.. _beat-system-overview-block:
......@@ -123,7 +123,7 @@ from the other groups. This is described in more details in the following
subsections. Finally, the field `description` is optional and gives a short
description of the algorithm.
The web client of the BEAT platform provides a graphical editor for algorithm,
The graphical interface of BEAT provides editor for algorithm,
which simplifies its `JSON`_ declaration definition.
......@@ -136,7 +136,7 @@ At the end of the processing workflow of an experiment, there is a special
kind of algorithm, which does not yield any output, but in contrast so called
`results`. These algorithms are called **analyzers**.
`Results` of an experiment are reported back to the user. Since the platform
`Results` of an experiment are reported back to the user. Since the BEAT
is concerned about data privacy, only a limited number of data formats can be
employed as results in an analyzer, such as boolean, integers, floating point
values, strings (of limited size), as well as plots (such as scatter or bar
......@@ -196,7 +196,7 @@ generates an ROC curve as well as few other metrics.
Source Code
...........
The BEAT platform has been designed to support algorithms written in different
The BEAT system has been designed to support algorithms written in different
programming languages. However, for each language, a corresponding back-end
needs to be implemented, which is in charge of connecting the inputs and
outputs to the algorithm and running its code as expected. In this section,
......@@ -231,8 +231,8 @@ At the very minimum, an algorithm class must look like this:
The class must be called ``Algorithm`` and must have a method called
``process()``, that takes as parameters a list of inputs (see section
:ref:`beat-core-algorithms-input-inputlist`) and a list of outputs (see
section :ref:`beat-core-algorithms-output-outputlist`). This method must
:ref:`beat-system-algorithms-input-inputlist`) and a list of outputs (see
section :ref:`beat-system-algorithms-output-outputlist`). This method must
return ``True`` if everything went correctly, and ``False`` if an error
occurred.
......@@ -295,7 +295,7 @@ Input list
An algorithm is given access to the **list of the inputs** of the processing
block. This list can be used to access each input individually, either by
their name (see section :ref:`beat-core-algorithms-input-name`), their index
their name (see section :ref:`beat-system-algorithms-input-name`), their index
or by iterating over the list:
.. code-block:: python
......@@ -354,10 +354,10 @@ Input naming
............
Each algorithm assign a name of its choice to each input (and output, see
section :ref:`beat-core-algorithms-output-name`). This mechanism ensures that algorithms
section :ref:`beat-system-algorithms-output-name`). This mechanism ensures that algorithms
are easily shareable between users.
For instance, in :numref:`beat-core-algorithms-input-naming`, two different users
For instance, in :numref:`beat-system-algorithms-input-naming`, two different users
(Joe and Bill) are using two different toolchains. Both toolchains have one
block with two entries and one output, with a similar set of data formats
(*image/rgb* and *label* on the inputs, *array/float* on the output), although
......@@ -365,7 +365,7 @@ not in the same order. The two blocks use different algorithms, which both
refers to their inputs and outputs using names of their choice
Nevertheless, Joe can choose to use Bill's algorithm instead of his own one.
When the algorithm to use is changed on the web interface, the platform will
When the algorithm to use is changed on the graphical interface, the system will
attempt to match each input with the names (and types) declared by the
algorithm. In case of ambiguity, the user will be asked to manually resolve it.
......@@ -410,7 +410,7 @@ Inputs synchronization
The data available on the different inputs from the synchronized channels
are (of course) synchronized. Let's consider the example toolchain on
:numref:`beat-core-algorithms-input-synchronization-example`, where:
:numref:`beat-system-algorithms-input-synchronization-example`, where:
* The image database provides two kind of data: some *images* and their
associated *labels*
......@@ -453,7 +453,7 @@ The following method is useable on a **list of inputs**:
Let's come back at the example toolchain on
:numref:`beat-core-algorithms-input-synchronization-example`, and assume
:numref:`beat-system-algorithms-input-synchronization-example`, and assume
that *block A* uses an autonomous algorithm. To iterate over all the data on
its inputs, the algorithm would do:
......@@ -546,7 +546,7 @@ keeps the others synchronized and iterate over all their data:
Feedback inputs
...............
The :numref:`beat-core-algorithms-input-feedbackloop-example` shows a toolchain
The :numref:`beat-system-algorithms-input-feedbackloop-example` shows a toolchain
containing a feedback loop. A special kind of input is needed in this scenario:
a *feedback input*, that isn't synchronized with the other inputs, and can be
freely used by the algorithm.
......@@ -572,7 +572,7 @@ Output list
An algorithm is given access to the **list of the outputs** of the processing
block. This list can be used to access each output individually, either by
their name (see section :ref:`beat-core-algorithms-output-name`), their index
their name (see section :ref:`beat-system-algorithms-output-name`), their index
or by iterating over the list:
.. code-block:: python
......@@ -629,7 +629,7 @@ Output naming
.............
Like for its inputs, each algorithm assign a name of its choice to each output
(see section :ref:`beat-core-algorithms-input-name` for more details) by
(see section :ref:`beat-system-algorithms-input-name` for more details) by
including them in the JSON declaration of the algorithm.
......@@ -667,7 +667,7 @@ Example 1: Write one block of data for each received block of data
Example 1: 6 images as input, 6 blocks of data produced
Consider the example toolchain on
:numref:`beat-core-algorithms-output-example1-figure`. We will implement a
:numref:`beat-system-algorithms-output-example1-figure`. We will implement a
*data-driven* algorithm that will write one block of data on the output of the
block for each image received on its inputs. This is the simplest case.
......@@ -731,7 +731,7 @@ Example 2: Skip some blocks of data
skipped
Consider the example toolchain on
:numref:`beat-core-algorithms-output-example2-figure`. This time, our algorithm
:numref:`beat-system-algorithms-output-example2-figure`. This time, our algorithm
will use a criterion to decide if it can perform its computation on an image or
not, and tell the platform that, for a particular data index, no data is
available.
......@@ -801,7 +801,7 @@ Example 3: Write one block of data related to several received blocks of data
Example 3: 6 images as input, 2 blocks of data produced
Consider the example toolchain on
:numref:`beat-core-algorithms-output-example3-figure`. This time, our algorithm
:numref:`beat-system-algorithms-output-example3-figure`. This time, our algorithm
will compute something using all the images with the same label (all the dogs,
all the cats) and write only one block of data related to all those images.
......@@ -809,7 +809,7 @@ The key here is the correct usage of the **current end data index** of the
input list to specify the indexes of the blocks of data we write on the output.
This ensure that the data will be synchronized everywhere in the toolchain: the
platform can now tell, for each of our data block, which image and label it
relates to (See section :ref:`beat-core-algorithms-input-synchronization`).
relates to (See section :ref:`beat-system-algorithms-input-synchronization`).
Additionally, since we can't know in advance if the image currently processed
is the last one with the current label, we need to memorize the current data
......
......@@ -21,7 +21,7 @@
.. with the BEAT platform. If not, see http://www.gnu.org/licenses/. ..
.. _beat:
.. _beat_general:
======
BEAT
......
......@@ -7,7 +7,7 @@
Beat Packages
-------------
* :ref:`beat`
* :ref:`beat_general`
* :ref:`beat_core`
* :ref:`beat_cmdline_introduction`
* :ref:`beat_backend_python`
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment