Unsupervised Real-time Classification of
Cycle Stages in Collaborative Robot Applications
Artúr István Károly†∗ , József Kuti†∗ , Péter Galambos†
† Antal Bejczy Center for Intelligent Robotics, Óbuda University, Bécsi út 96/B. H-1034 Budapest, Hungary
∗ Doctoral School of Applied Informatics and Applied Mathematics, Óbuda University,
Bécsi út 96/B. H-1034 Budapest, Hungary
E-mail: {artur.karoly|jozsef.kuti|peter.galambos}@irob.uni-obuda.hu
Abstract—Recent robot applications often operate at a level
of autonomy that does not need strictly structured environment
within the robot cells. Human-Robot collaboration introduces
further uncertain aspects, which in turn makes the production
cycle non-deterministic. It renders difficulties for manufacturing
companies regarding planning, control, quality assurance, etc.
The latest robot controllers allow access to internal states (joint
angles, accelerations, drive torques, etc.) at a high sampling
rate, which can be acquired, processed by an appropriate
service connected to the ERP system, developing cyber-physical
control and monitoring infrastructure. This study introduces an
online technique for automatic and unsupervised clustering of
elementary steps in collaborative robot applications based on
real-time force/torque data stream. The proposed unsupervised
clustering solution utilizes dynamically trained one class support
vector machines (OCSVM) to discover the states of the repetitive
process. The method is demonstrated and evaluated in a real-
istic experimental environment. Initial results show promising
performance characteristics.
Index Terms—Industry 4.0, Collaborative Robots, Cyber-
physical control, Big data, SVM, IoT
I. I NTRODUCTION
Machine learning and AI are appearing in almost every
industry imperceptibly influencing our everyday life as well
as the professional services and military applications. Man-
ufacturing industry can be a primary beneficiary of these
achievements and research projects related to the Industry 4.0
concepts exploit the possibilities with enormous efforts.
From the immense amount of data acquired from man-
ufacturing processes, we can distill useful information and
synthesize appropriate interventions or just logging historical
data for quality assurance purposes [1], [2]. Acquisition of
raw data and the storage capacity is not a problem anymore.
However, there is a strong need for solutions which are capable
of exploring correlations and make decisions in real-time.
Therefore, many recent studies are dealing with online meth-
ods especially with the reformulation of techniques originally
developed for analysis of historical data [3].
Our research team focuses on models and methods that are
appropriate for real-time monitoring of advanced collaborative
robot applications. In this paper, we consider the event log-
ging and anomaly detection of non-deterministic processes.
In contrast to the traditional industrial robot cells, modern
robots with advanced perception capabilities are working in a
less structured environment even sharing the workspace with
human workers. These circumstances introduce significant
uncertainties in the robot operation that might result in sig-
nificant fluctuation of cycle time and make the overall process
challenging to supervise. E.g., The efficiency of a collaborative
cell may vary shaft by shaft due to the individual skills or
practice of the human worker. These sort of irregularities
could be revealed and appropriately handled using autonomous
observation systems on the ERP level that can supervise many
processes in a unified manner without tailoring each robot
programs individually. Such a generic supervisory module fits
well to the existing infrastructure which usually utilize, e.g.,
SCADA [4] concepts or the recently emerging OPC UA [5]
solutions.
Considering the above discussed problem, we can lay down
the most important characteristics of the system:
• Human activity must be minimized in the training and
setup process.
• Process-step classification and anomaly detection must
be based on generic data sets available on modern
robot controllers. E.g., joint-space coordinates/speeds/ac-
celerations, Cartesian pose/speed/acceleration, forces and
torques, etc.
• Classification must be performed online to avoid the long-
term storage of dense data.
• Number of states are not known apriori.
• So-called concept drift [6] and concept evolution [7] must
be handled.
These requirements limit the suitable approaches to the set
of light-weight unsupervised classification methods. Before
the implementation and experimental work, several techniques
have been investigated which may comply with the require-
ments.
In the literature, there are online clustering approaches based
on the k-means method [8], [9]. Since during the training, and
even in the inference phase new events/states may occur, we
cannot determine an appropriate k value (number of clusters)
in advance. Too large k leads too many classes dividing states
that should be considered as a single state. Thus, for too
small k, the resolution might not be enough to distinguish
each different application states. The number of groups could
be changed adaptively, but it requires the re-calculation of
the group center points [8]. Even though there exists some
theoretically viable solutions such as [10], it is time-consuming
and therefore makes the real-time operation impossible. For
these reasons, the k-means algorithm and its extensions are
not suitable for our purpose.
Recurrent Neural Networks (RNN) are also inspected as
a potential solution, since these techniques are developed
for processing sequential input [11]. The main problem with
RNNs is the unsupervised training. Even the offline training
with labeled data is non-trivial because of the issues with the
Backpropagation Through Time algorithm like the vanishing
gradient problem [11], [12]. Magdalena Klapper-Rybicka et
al. in [13] introduced an unsupervised training method for an
LSTM network. In [14] Luca Pasa and Alessandro Sperduti
propose a solution using linear autoencoder for pre-training
of RNNs that eliminates the vanishing gradient in a large
measure. Since the number of neurons in the hidden layer
is fixed, the number of classes cannot be varied online. RNNs
might be very powerful in other robotics-related problems, but
unfortunately, it is not appropriate for the clustering problem
discussed in this paper.
Several papers e.g., [15]–[17] utilizes the One Class SVM
(OCSVM) method to discover anomalies in complex data
flows. Encouraged by these promising results, a novel solution
has been implemented inspired by the OCSVM technique. In
this study, we provide a detailed discussion of our approach,
that is validated through a life-like collaborative robot appli-
cation.
The paper is structured as follows: Section II recalls the
OCSVM algorithm discussing the so-called kernel trick (II-A)
and the realizations (II-B) as well as the extended algorithm
for the discussed classification problem. The experimental
evaluation and the details of implementation are discussed in
Section III. Section IV summarizes the study.
II. M ETHODOLOGY
After the thorough investigation of some potential ap-
proaches, we have developed an extended algorithm based on
the OCSVM method that fulfills all the requirements collected
in the Introduction.
Support Vector Machine (SVM) [18] is developed for two-
class-problems (binary classifier) and needs labeled training
data. SVM is widely used in plenty of applications and
effectively combined with many other paradigms e.g., fuzzy
logic [19]. In contrast, the OCSVM is designed to distinguish
samples belong to one class from the rest of the samples [20],
[21]. Therefore, unsupervised training is viable using a set of
unlabeled samples that represents the given class.
In the majority of robot applications, a single sample of
momentary parameters does not characterize the actual process
step with a solid confidence. For this reason, a windowed data
stream is used as input of the classifier. The size of the window
primarily determines the length of application-states which
should be handled by the classifier. Due to the windowing, the
input array can reach very high dimensionality, since a single
typical sample contains six scalars (e.g., forces and torques at
the TCP). This implies a trade-off between the window length,
the sampling rate, and the real-time performance.
In the following subsections, let us recall the details of the
realization of the OCSVM technique.
A. The kernel-trick
In most cases, the input samples are not linearly separable.
Just like in general robot applications considering windowed
force/torque stream as input. In such cases, the so-called
kernel-trick is applied to make the samples separable [22].
Using the kernel-trick, the SVM can be designed in a higher
dimensional space than the dimensionality of the input array.
Via an appropriate - usually nonlinear - transformation, in
the higher dimensional space, the samples become linearly
separable. The point of the kernel-trick is that formulation of
the inner product (required for distance computation) does not
require the knowledge of the transformation if a function can
be found that gives the same result with less computation. This
function is referred to as kernel function [22].
The kernel-trick enables the classifier design in infinite
dimensional space using, for example, the so-called Gauss
kernel a.k.a., Radial Basis Function (RBF) (eq. 1).

kxi − xj k2

K(xi , xj ) = exp − , (1)
2σ 2
where the kernel parameter σ should be set to a suitably
1
chosen value. It is often substituted by γ = , which allows
2σ 2
further simplification that results in eq. 2.
K(xi , xj ) = exp −γkxi − xj k2


(2)
This modified kernel function appropriately characterizes
the distance between the samples. By tuning the parameter σ,
the sensitivity of the kernel function can be influenced.
The series expansion of the RBF kernel function leads to
an infinite series, in which the terms
2 3
hxi , xj i , hxi , xj i , hxi , xj i . . .
are present, which are also kernel functions. This way, the
OCSVM classifier can be designed in arbitrary dimensional
feature space [23].
B. Realization of OCSVM
There are two usual practices to implement OCSVM.
Schlkopf et al. in [20] separate the training samples from the
origo with a hyperplane in the feature space maximizing the
distance between the hyperplane and the origo. This way the
OCSVM projects the input space to 0 or 1. The classifier-
design leads to a quadratic programming problem formalized
in eq. 3 [20].
n
!
1 2 1 X
min kwk2 + ξi − ρ
w,ξi ,ρ 2 νn i=1
(3)
w · Φ(xi ) ≥ ρ − ξi ∀i
ξi ≥ 0 ∀i
, where Φ(xi ) is the function that transforms the ith sample Algorithm 1
to the feature space, ρ is the size of the margin, ξi is the loss 1: procedure U NSUPERVISED CLUSTERING ALGORITHM
defined by the distances of outliers from the hyperplane, while
ν is a parameter to set the trade-off between the number of 2: Definitions:
outliers and the accuracy of the decision boundary. 3: frame = the basic data structure
The quadratic programming problem (eq. 3) can be solved 4: samplesize // the number of frames in a sample
by the Lagrange-multiplier method that leads to the decision 5: samplingwin = a sliding window containing the latest
function samplesize number of frames
6: trainingsample = a non overlapping sliding window
n
! with samplesize number of frames for training
samplenum // Number of trainngsamples in the
X
7:
f (x) = sgn(w · Φ(xi ) − ρ) = sgn αi K(x, xi ) − ρ
i=1
training set
(4) 8: trainingset = A set of the latest samplenum number of
where, αi are the Lagrange multipliers. trainingsamples
The second method is recalled based on the work of David 9: ensemble = An array containing the trained OCSVM
M.J. Tax s Robert P.W. Duin [21]. Instead of the separation models
by a hyperplane, the training samples in the feature space are 10: predictions = An array that holds the class predictions
delimited by a spherical surface and minimizes the volume from all of the OCSVMs
of the hypersphere. This hypersphere is characterized by the
center a and the radius R > 0. The center a is composed of 11: Data preparation:
the linear combination of the support vectors. The hypersphere 12: for all frame do
does not necessarily enclose all training samples (soft margin). 13: frame → samplingwin
In this case, a loss function determines the penalty associated 14: if samplingwin.size() > samplesize then
with samples outside of the hypersphere. The equations of 15: samplingwin.erase(0) // sliding win-
the spherical method are represented by Eq. 5, where the dow for class prediction
parameter C tunes the penalty function. 16: frame → trainingsample
17: if trainingsample.size() == samplesize then
n
X 18: trainingsample → trainingset
min R2 + C ξi
R,a 19: if trainingset.size() > samplenum then
i=1
(5) 20: trainingset.erase(0)
kxi − ak2 ≤ R2 + ξi ∀i
21: trainingsample = ∅ // non overlapping
ξi ≥ 0 ∀i window for training
This minimization problem also solvable by the Lagrange
multiplier method, that results in a decision function which 22: Online training:
classifies the sample z as a class member if the distance of 23: for all frame do
the sample and the center a is smaller than the radius R. The 24: for all OCSVM ∈ ensemble do
distance is calculated with the RBF kernel function. 25: OCSVM.predict(samplingwin) → predictions
26: if ∀p ∈ predictions p == -1 then
C. Extended algorithm for unsupervised clustering 27: new OCSVM.train(trainingset) → ensemble
Algorithm 1 shows our solution for the proposed problem. 28: else
The algorithm has four major parts. In the Definitions section, 29: new state = p.index where p 6= -1
we introduce the variables needed for the formalization of the 30: update correl matrix()
algorithm.
The Data preparation section shows the process of setting 31: Inference mode:
up our data structures. We used different structures for the 32: for all frame do
predictions and for the training of the OCSMs. For the 33: for all OCSVM ∈ ensemble do
predictions we used the values stored in samplingwin, which 34: OCSVM.predict(samplingwin) → predictions
is a sliding window containing the latest samplesize number
of frames. Whenever a new frame is available it is pushed into Function: update correl matrix()
the samplingwin window and the least up-to-date frame gets 1: for (i = 0; i < predictions.size(); i + +) do
dropped. This means that for every new frame we have a new 2: if predictions[i] == 1 then
sample from which our model can make predictions. So the 3: for (j = 0; j < prepredictions.size(); j + +) do
algorithm will have a prediction for every new frame which 4: if predictions[j] == 1 then
is the highest response rate that we can get. However, for the 5: correl matrix[i][j] + + // this ma-
training of the OCSVMs we used non-overlapping samples trix holds which OCSVMs fired together
(trainingsample) because overlapping samples contain frames
multiple times and this causes the OCSVM model to overfit,
as the samples will be extremely close to each other in feature
space.
During the Online training section, the algorithm makes
predictions for all of the trained OCSVMs whenever a new
frame is available. If none of the trained OCSVMs recognize
the current sample (samplingwin) as one belonging to the stage
represented by that OCSVM, the new sample is assumed to
belong to a yet unseen stage, and a new OCSVM is trained
for that particular stage. This way the number of OCSVMs,
so the number of recogniseable stages, grows as time passes
and the robot application is running. The number of OCSVMs
won’t grow beyond a limit as the robot application is repetitive
(made up of cycles) so the same stages will be repeated and
recognised.
The Inference mode is used when the regular behavior of the
robot during the application has been mapped, and there are
no more unrecognized states. In inference mode, there is no
training just prediction. Any sample that belongs to an unseen
state is considered an anomaly because the normal functioning
of the robot has already been taught to the model.
The elements of the correl matrix (correlation matrix) vari-
able show which OCSVMs predict the same for most of the
samples. Reasonably, if two OCSVMs predict the same for
more than 95% of the samples than those two OCSVMs are
trained for almost the same state. This way, very similar states
can be detected and merged if necessary.
III. E XPERIMENTAL INVESTIGATION
We validated our OCSVM-based extended algorithm
through a life-like collaborative robot application using the
KUKA LBR iiwa 7-DOF industrial robot that fulfills the
regulations of the EN ISO 13849 machine safety standard
applies for collaborative robots. It is mostly used for assem-
bly applications dealing with the non-ergonomic and highly
repetitive jobs while the human worker is responsible for the
tasks that require more developed manual skills. As a result
of the shared workspace processes in such applications be-
come highly non-deterministic. For the validation of an online
clustering algorithm, we also had to consider the presence of
concept drift and concept evolution.
In order to investigate the true potential of our algorithm,
we set up a robot application in a way that it holds the
major characteristics which may cause difficulties in online
unsupervised clustering problems.
Our main requirements towards the robot application:
1) The application must consist of clearly separable stages.
2) During the operation, there must be continually changing
circumstances so concept drift can develop.
3) In the application, unplanned effects (anomalies) should
appear at unexpected times.
4) The application must exploit the collaborative nature of
the robot.
Our experimental investigation aimed to be able to identify
stages of the robot application with our method shown in
Algorithm 1.
A. Experimental setup
In our test environment, the robot draws polygons on a sheet
of paper using a pencil as a tool. The application consists of
two parts. During the first part, the human operator can teach
the four vertices of a quadrilateral by moving the robot’s flange
by hand.
During the second part of the application the robot functions
on its own (no collaboration). It starts drawing polygons by
connecting the previously learned vertexes with straight lines.
When a polygon is complete, the robot makes a short line
segment towards the center of the polygon and draws a smaller
concentric polygon inside the previous one. The robot draws
the first two edges with a different pencil orientation from the
last two ones to have better tilt angle. Altogether, 15 polygons
follow this pattern. After the 15th polygon the cycle starts
again from drawing the largest one.
Drawing different sides of the polygons are clearly separable
stages of the process. In the experiments, we considered this
part of the robot application, and the goal of the algorithm
was to differentiate and recognize four stages corresponding
to the drawing of the four sides of the polygons.
Both concept drift and concept evolution appear in the
experiment, as the top of the pencil gradually wears away and
the robot draws smaller and smaller polygons in one cycle.
The robot application detects if the tip of the pencil is
beyond a certain wearing limit. If the tip becomes too small,
the robot finishes drawing the given polygon and then sharpens
the pencil with a fixed pencil sharpener in its workspace.
The pencil can reach the critical wear or even break out at
any time. Fugure 1. shows the robot performing the drawing
task. The so-constructed robot application fulfills all specified
requirements.
Fig. 1. The experimental robot application
B. Implementation details
We used the data stream of 3D Cartesian force and torque
values in the TCP coordinate system as the input data for our
algorithm. So one frame consisted of six scalar values. First each samples and about 1.5s for a training set supposing a
of all, a communication channel had to be created to ensure 200Hz sampling frequency. This parameter should be adjusted
the availability of the data. according to the typical duration of the working phases to be
We extracted the data stream from the robot controller distinguished.
using the Robot Operating System (ROS) framework [24]. The To obtain a correct reference, not only the force and torque
robot application creates a publisher for a ROS topic with the data are acquired but the TCP Cartesian positions as well.
iiwa stack ROS package [25]. Our algorithm was implemented In this way, each phases can be distinguished with straight
in Node.js environment and uses the rosnodejs library [26] to forward heuristics, obtaining a basis for the comparison this
create a subscriber to the given ROS topic. way.
For the sake of testing our algorithm, we recorded the data In the test, two full working cycles was performed, so the
stream coming from the robot to have a reliable basis of robot drew 15 concentric polygons two times consecutively.
comparison. First, we set up the model parameters such as The results show, that after ≈ 25000 samples (before the
the number of frames per sample and number of samples in end of the first full cycle), the number of OCSVM is not in
the training set on a recorded data stream. Then we tested increasing further (no more unknown states occure) and the
the model with different parameter sets on another recorded state transients became regular clearly representing the phases
stream to avoid overfitting. of the process. The occurence of new states during the training
The complete data flow of the experiment can be seen phase can be seen in figure 4.
in figure 2. The dashed line indicates the scope of our
implementation. The blue box (Data processing) is performing 0.57
the Algorithm 1. The input data stream arrives directly from 0.56
0.55
A A 1.
B
B C D A
4.
B
A
D C D C
the robot controller via peer-to-peer communication. The ROS 0.54
x [m]

0.53
master provides address lookup so the publisher and the 0.52
0.51
0.5
subscriber can exchange data directly. The results of the 0.49
A
D
2.
B
C
A
D 3.
B
C
0.48
predictions and the trained OCSVM models are logged on 160 161 162 163 164 165 166 167 168 169
18
the console and can be written to file as well. The stream 16
14
State ID

of predictions is also sent to the http server which forwards 12

10
8
the stream to the clients through websockets for visualization 6
4
purpose. 160 161 162 163 164 165 166 167 168 169
time [s]

Fig. 3. Results of the clustering in inference mode

Figure 3 shows the results for one quadrilateral drawing

Fig. 2. Data-oriented explanation of the experimental environment
C. Evaluation
We have evaluated the performance of the classification
using real data recorded from the robot application. The main
performance measure is how the automatically detected states
can be associated with the real-world working phases of the
robot cell. For the purpose of testing, the part of the application
is considered in which the robot draws the four sides of the
polygon. Accordingly, the four states are associated with the
four sides.
During the tests, a window-size of 15 frames and training
sets with 20 samples was applied, which means 0.075s for
cycle after the training phase. One can see, that the 4 line
segment and the shrinking line is merged into a common state,
as well as the 2. line segments and the consecutive orientation
change. The figure clearly shows, that the state transitions
coincide with the location where the vertices are drawn.
IV. C ONCLUSION
In this study, we investigated the possibilities of real-
time recognition of regular working steps and detection of
anomalies in complex robot applications by analyzing the
interaction force/torque data-stream online. After disapproving
RNN-based and K-means clustering methods, we constructed
an unsupervised classifier algorithm utilizing one class SVMs
(OCSVMs). The proposed methodology was demonstrated in
a real experimental environment through a complex robot
application. The evaluation tests showed that the algorithm
is capable of differentiating a finite number of process steps
with real-time performance without the need of labeled data
in the training phase.
ACKNOWLEDGEMENTS
Authors thankfully acknowledge the financial support of
this work by the Hungarian State and the European Union
under the EFOP-3.6.1-16-2016-00010 project and the financial
 0.6
0.58
0.56
0.54
x [m]

0.52
0.5
0.48
0.46
0 20 40 60 80 100
Number of states / State ID

16
14 Number of recognisable states
12 State ID
10
8
6
4
2
0
−2
0 20 40 60 80 100
time [s]

Fig. 4. Evolution of the classifier in the training phase

support by the ÚNKP-16-3 and ÚNKP-16-4 New National
Excellence Program of the Ministry of Human Capacities.
R EFERENCES
[1] D. Braha, Data Mining for Design and Manufacturing: Methods and
Applications. Springer Science & Business Media, Mar. 2013.
[2] E. Olsson, P. Funk, and N. Xiong, “Fault diagnosis in industry using
sensor readings and case-based reasoning,” Journal of Intelligent &
Fuzzy Systems, vol. 15, no. 1, pp. 41–46, Jan. 2004.
[3] A. K. Choudhary, J. A. Harding, and M. K. Tiwari, “Data mining in
manufacturing: a review based on the kind of knowledge,” Journal of
Intelligent Manufacturing, vol. 20, no. 5, pp. 501–521, Oct. 2009.
[4] S. A. Boyer, Scada: Supervisory Control And Data Acquisition, 4th ed.
USA: International Society of Automation, 2009.
[5] W. Mahnke, S.-H. Leitner, and M. Damm, OPC Unified Architecture.
Springer Science & Business Media, Apr. 2009.
[6] A. Tsymbal, “The problem of concept drift: definitions and related
work,” Computer Science Department, Trinity College Dublin, vol. 106,
no. 2, 2004.
[7] M. M. Masud, Q. Chen, L. Khan, C. Aggarwal, J. Gao, J. Han, and
B. Thuraisingham, “Addressing Concept-Evolution in Concept-Drifting
Data Streams,” in 2010 IEEE International Conference on Data Mining,
2010, pp. 929–934.
[8] E. Liberty, R. Sriharsha, and M. Sviridenko, “An Algorithm for On-
line K-Means Clustering,” arXiv:1412.5721 [cs], Dec. 2014, arXiv:
1412.5721.
[9] L. Morissette and S. Chartier, “The k-means clustering technique:
General considerations and implementation in Mathematica,” Tutorials
in Quantitative Methods for Psychology, vol. 9, pp. 15–24, 2013.
[10] I. Bonet, A. Escobar, A. Mesa-Múnera, and J. F. Alzate, “Clustering
of metagenomic data by combining different distance functions,” Acta
Polytechnica Hungarica, vol. 14, no. 3, pp. 223–236, 2017.
[11] Y. Bengio, P. Simard, and P. Frasconi, “Learning long-term dependen-
cies with gradient descent is difficult,” IEEE Transactions on Neural
Networks, vol. 5, no. 2, pp. 157–166, Mar. 1994.
[12] Y. Bengio, P. Frasconi, and P. Simard, “The problem of learning
long-term dependencies in recurrent networks,” in IEEE International
Conference on Neural Networks, 1993.
[13] M. Klapper-Rybicka, N. N. Schraudolph, and J. Schmidhuber, “Unsu-
pervised Learning in LSTM Recurrent Neural Networks,” in Artificial
Neural Networks ICANN 2001, ser. Lecture Notes in Computer Science.
Springer, Berlin, Heidelberg, Aug. 2001, pp. 684–691.
[14] L. Pasa and A. Sperduti, “Pre-training of recurrent neural networks
via linear autoencoders,” in Advances in Neural Information Processing
Systems, 2014, pp. 3572–3580.
[15] Z. Ghafoori, S. M. Erfani, S. Rajasegarar, S. Karunasekera, and C. A.
Leckie, “Anomaly detection in non-stationary data: Ensemble based self-
adaptive OCSVM,” in Neural Networks (IJCNN), 2016 International
Joint Conference on. IEEE, 2016, pp. 2476–2483.
[16] A. Gretton and F. Desobry, “On-line one-class support vector machines.
An application to signal segmentation,” in Acoustics, Speech, and Signal
Processing, 2003. Proceedings.(ICASSP’03). 2003 IEEE International
Conference on, vol. 2. IEEE, 2003, pp. II–709.
[17] J. Ma and S. Perkins, “Time-series novelty detection using one-class
support vector machines,” in Neural Networks, 2003. Proceedings of the
International Joint Conference on, vol. 3. IEEE, 2003, pp. 1741–1745.
[18] C. Cortes and V. Vapnik, “Support-vector networks,” Machine Learning,
vol. 20, no. 3, pp. 273–297, Sep. 1995.
[19] J. Menyhárt and R. Szabolcsi, “Support vector machine and fuzzy logic,”
Acta Polytechnica Hungarica, vol. 13, no. 5, pp. 205–220, 2016.
[20] B. Schlkopf, R. C. Williamson, A. J. Smola, J. Shawe-Taylor, and J. C.
Platt, “Support vector method for novelty detection,” in Advances in
neural information processing systems, 2000, pp. 582–588.
[21] D. M. J. Tax and R. P. W. Duin, “Support Vector Data Description,”
Machine Learning, vol. 54, no. 1, pp. 45–66, Jan. 2004.
[22] B. Schlkopf, “The Kernel Trick for Distances,” in Proceedings of
the 13th International Conference on Neural Information Processing
Systems, ser. NIPS’00. Cambridge, MA, USA: MIT Press, 2000, pp.
283–289.
[23] B. E. Boser, I. M. Guyon, and V. N. Vapnik, “A Training Algorithm
for Optimal Margin Classifiers,” in Proceedings of the Fifth Annual
Workshop on Computational Learning Theory, ser. COLT ’92. New
York, NY, USA: ACM, 1992, pp. 144–152.
[24] M. Quigley, K. Conley, B. Gerkey, J. Faust, T. Foote, J. Leibs,
R. Wheeler, and A. Y. Ng, “ROS: an open-source Robot Operating
System,” in ICRA workshop on open source software, vol. 3. Kobe,
2009, p. 5.
[25] C. Hennersperger, B. Fuerst, S. Virga, O. Zettinig, B. Frisch, T. Neff,
and N. Navab, “Towards mri-based autonomous robotic us acquisitions:
A first feasibility study,” IEEE transactions on medical imaging, 2016.
[26] “rosnodejs: Client library for writing ROS nodes in JavaScript with
nodejs,” Sep. 2017, original-date: 2016-03-30T18:44:11Z. [Online].
Available: https://github.com/RethinkRobotics-opensource/rosnodejs

View publication stats