# SpikE: spike-based embeddings for
multi-relational graph data

Dominik Dold, Josep Soler Garrido  Siemens AI Lab
Siemens AG Technology
80331 Munich, Germany
{dominik.dold<EMAIL_ADDRESS>
###### Abstract

Despite the recent success of reconciling spike-based coding with the error
backpropagation algorithm, spiking neural networks are still mostly applied to
tasks stemming from sensory processing, operating on traditional data
structures like visual or auditory data. A rich data representation that finds
wide application in industry and research is the so-called knowledge graph – a
graph-based structure where entities are depicted as nodes and relations
between them as edges. Complex systems like molecules, social networks and
industrial factory systems can be described using the common language of
knowledge graphs, allowing the usage of graph embedding algorithms to make
context-aware predictions in these information-packed environments. We propose
a spike-based algorithm where nodes in a graph are represented by single spike
times of neuron populations and relations as spike time differences between
populations. Learning such spike-based embeddings only requires knowledge
about spike times and spike time differences, compatible with recently
proposed frameworks for training spiking neural networks. The presented model
is easily mapped to current neuromorphic hardware systems and thereby moves
inference on knowledge graphs into a domain where these architectures thrive,
unlocking a promising industrial application area for this technology.

85(17.5,259.5) ©2021 IEEE. Personal use of this material is permitted.
Permission from IEEE must be obtained for all other uses, in any current or
future media, including reprinting/republishing this material for advertising
or promotional purposes, creating new collective works, for resale or
redistribution to servers or lists, or reuse of any copyrighted component of
this work in other works.

##  I Introduction

Recently, spiking neural networks (SNNs) have started to bridge the gap to
their widely used cousins, artificial neural networks, and achieved
competitive performances on benchmark tasks like pattern recognition [1, 2, 3,
4, 5, 6], probabilistic inference [7, 8, 9] and sequence prediction tasks [10,
11]. One crucial ingredient for this success was the consolidation of the
error backpropagation algorithm with SNNs, which had remained an unsolved
problem for a long time due to the discontinuous nature of spike generation
[2, 12, 13, 14]. However, so far SNNs have mostly been applied to tasks akin
to sensory processing like image or audio recognition [15]. Such input data is
inherently well-structured, e.g., the pixels in an image have fixed positions,
and applicability is often limited to a narrow set of tasks that utilize this
structure and do not scale well beyond the initial data domain.

A data structure that allows reasoning over abstract concepts and seamless
integration of data from different domains are knowledge graphs (KGs) [16, 17,
18]. KGs are a widely used, rich data structure that enables a symbolic
description of abstract concepts and how they relate to each other. In
general, a KG consists of nodes representing entities and edges representing
relations between these entities. For instance, in an industrial automation
system, the nodes could represent physical objects like a sensor or a
programmable logic controller (PLC), but also more abstract entities like an
IP address, data types or an application running on the industrial system
(Fig. 1A).

Figure 1: (A) Simplified example of a graph describing parts of an industrial
automation system, with nodes representing entities and edges relations.
Relation types are shown in different colors. (B) The graph can be summarized
as a set of known triple statements. Inference on graph data is concerned with
evaluating whether unknown statements are plausible given the structure of the
observed graph.

How these entities relate to each other is modeled with edges of different
types between nodes. This way, the graph can be summarized using semantically
meaningful statements, so-called triples, that take the simple and human-
readable form {subject, predicate, object} [19], or in graph format, {node,
typed edge, node} (Fig. 1B).

Although multi-relational graphs are highly expressive, their symbolic nature
prevents the direct usage of classical statistical methods for further
processing and evaluation. Lately, graph embedding algorithms have been
introduced to solve this problem by mapping nodes and edges to a vector space
while conserving certain graph properties [20, 21, 22]. For example, one might
want to conserve a node’s proximity, such that connected nodes or nodes with
vastly overlapping neighborhoods are mapped to vectors that are close to each
other. These vector representations can then be used in traditional machine
learning approaches to make predictions about unseen statements, realizing
abstract reasoning over a set of subjects, predicates and objects.

Spike-based versions of classical graph algorithms like finding shortest
paths, minimum spanning trees and maximum flows have already been proposed in
recent work [23, 24, 25, 26, 27, 28, 29]. We extend this work to graph
embeddings for multi-relational graphs, where instead of working directly with
the graph structure, it is encoded in the temporal domain of spikes: entities
and relations are represented as spikes of neuron populations and spike time
differences between populations, respectively. Through this mapping from graph
to spike-based coding, SNNs can be trained on graph data to evaluate novel
triples not seen during training, i.e., perform inference on the semantic
space spanned by the training graph. For our studies, we use non-leaky
integrate-and-fire neurons (nLIF), allowing us to calculate spike times and
spike time gradients analytically [1] while guaranteeing compatibility with
current neuromorphic hardware architectures [30, 31] that often realize some
variant of the LIF neuron model. The presented results are especially
interesting for the applicability of neuromorphic hardware in industrial use-
cases [32], where graph embedding algorithms find many applications, e.g., in
form of recommendation systems [33], digital twins [34], semantic feature
selectors [35] or anomaly detectors [36].

In the following, we first explain our spike-based graph embedding model
(SpikE), derive the required learning rule and evaluate the learned embeddings
on a realistic industrial benchmark data set.

##  II Spike-based graph embeddings

###  II-A From graphs to spikes

Our model takes inspiration from TransE [37], a shallow graph embedding
algorithm where nodes are represented as vectors and relations as vector
translations. In principle, we found that these vector representations can be
mapped to spike times and translations into spike time differences, offering a
natural transition from the graph domain to SNNs.

We propose that the embedding of a node $s$ is given by single spike times of
a neuron population of size $N$,
$\boldsymbol{t}_{s}\in[t_{0},t_{\mathrm{max}}]^{N}\in\mathbb{R}^{N}$ (Fig.
2A). That is, every neuron of the population emits exactly one spike during
the time interval $[t_{0},t_{\mathrm{max}}]$, and the resulting spike pattern
represents the embedding of an entity in the KG. Relations are encoded by a
$N$-dimensional vector of spike time differences
$\boldsymbol{r}_{p}\in\mathbb{R}^{N}$. To decode whether two populations $s$
and $o$ encode entities that are connected by relation $p$, we evaluate the
spike time differences of both populations element-wise,
$\boldsymbol{t}_{s}-\boldsymbol{t}_{o}$, and compare it to the entries of the
relation vector $\boldsymbol{r}_{p}$ (Fig. 2A). Depending on how far these
diverge from each other, the statement {$s$, $p$, $o$} is either deemed
plausible or implausible. For instance, in Fig. 2B (top), the spike pattern of
the two populations encoding subject and object entity are consistent with the
representation of the relation, i.e.,
$\boldsymbol{t}_{s}-\boldsymbol{t}_{o}\approx\boldsymbol{r}_{p}$, and hence
the triple {$s$, $p$, $o$} is deemed plausible. In Fig. 2B (bottom), we choose
a triple {$s$, $q$, $b$} that is assessed as implausible by our model, since
the measured spike time differences do not match those required for relation
$q$, i.e., $\boldsymbol{t}_{s}-\boldsymbol{t}_{b}\neq\boldsymbol{r}_{q}$
(although they might match other relations).

Figure 2: (A) Spike-based coding scheme to embed graphs into SNNs. Nodes are
represented by neuron populations (red, blue), where the embedding is given by
the individual spike time of each neuron. By comparing spike time differences
between populations (triangles), one can evaluate whether certain relations
(gray boxes) are valid between the two entities encoded by the populations.
(B) Example of spike patterns and spike time differences for a plausible
triple (top) and an implausible one (bottom), i.e., where the pattern does not
match the relation, pop. 1 $-$ pop. 2 $\neq$ relation. In both cases, we used
the same subject (red), but different relations and objects (gray and blue).

This coding scheme maps the rich semantic space of graphs into the spike
domain, where the spike patterns of two populations encode how the represented
entities relate to each other, but not only for one single relation, but the
whole set of relations spanning the semantic space. To achieve this, learned
relations encompass a range of patterns from mere coincidence detection to
complex spike time patterns. In fact, coding of relations as spike coincidence
detection does naturally occur as a special case in our model when training
SNNs on real data, see for example Footnote 2C. Such spike embeddings can
either be used directly to predict or evaluate novel triples, or as input to
other SNNs that can then utilize the semantic structure encoded in the
embeddings for subsequent tasks.

Figure 3: (A) Illustration of the proposed network architecture. Fixed spikes
(black) and plastic weights (blue) encode the spike times of the embedding
populations (gold), which statically project to dendritic compartments of
output neurons (gray)111To ease notation, the upper index denotes relation
types and the lower index vector components here.. To score triples, the
adequate populations are activated using, e.g., a disinhibition mechanism
(orange)222For SpikE, the order in which the spike time differences are
calculated is crucial. This can be achieved by either using a more involved
gating mechanism (Gating with parrot neurons), or by representing each entity
via subject and object populations that are synchronized during training
(Synchronizing subject and object population).. (B) Fixed stimulus spikes
(black) and examples of learned spike time embeddings for SpikE-S (gold) and
SpikE (red). (C) Learned relation embeddings in the output neurons. In case of
SpikE-S, only positive spike time differences are learned. In both cases,
complex spike difference patterns are learned to encode relations as well as
simpler ones that mostly rely on coincidence detection (middle), i.e.,
$\boldsymbol{r}_{p}\approx 0$. (D) Temporal evaluation of triples {$s$, $p$,
$o$}, for varying degrees of plausibility of the object: (green) seen during
training, (orange) not seen during training, but plausible and (red) least
plausible (see also Fig. 6A for a similar experiment). Different to TransE
that lacks a concept of time, SpikE prefers embeddings where most neurons
spike early, allowing faster evaluation of scores. Lines mark the mean score
and shaded areas the 15th and 85th percentile for 10 random seeds.

Formally, the ranking of triples can be written as

$\vartheta_{s,p,o}=\sum\|d\left(\boldsymbol{t}_{s},\boldsymbol{t}_{o}\right)-\boldsymbol{r}_{p}\|\,,$
(1)

where $d:\mathbb{R}^{N}\times\mathbb{R}^{N}\to\mathbb{R}^{N}$ is a difference
function and the sum is over vector components. In the remaining document, we
call $\vartheta_{s,p,o}$ the score of triple {$s$, $p$, $o$}, where plausible
triples have a score close to $0$ and implausible ones $\gg 0$. For SpikE, we
define the difference function to be

$d_{\mathrm{A}}\left(\boldsymbol{t}_{s},\boldsymbol{t}_{o}\right)=\boldsymbol{t}_{s}-\boldsymbol{t}_{o}\,,$
(2)

where both the order and distance of spike times are used to encode relations.
This can be further modified to only incorporate spike time differences,

$d_{\mathrm{S}}\left(\boldsymbol{t}_{s},\boldsymbol{t}_{o}\right)=\|\boldsymbol{t}_{s}-\boldsymbol{t}_{o}\|\,,$
(3)

such that there is no distinction between subject and object populations. We
call this version of the model SpikE-S, which enables a more compact network
realization since the same neuron population can be used to represent an
entity as subject and object. In contrast, SpikE has the benefit of being
closer to the original TransE algorithm by utilizing spike time ordering, but
might be harder to realize in neuromorphic hardware (see Footnote 2A for
details). For the sake of completeness, we investigate both versions of the
spike-based embedding model.

###  II-B Network implementation

A suitable neuron model that suffices the requirements of the presented coding
scheme, i.e., single-spike coding and being analytically treatable, is the
nLIF neuron model. For similar reasons, it has recently been used in
hierarchical networks utilizing first-spike latency codes [1]. For the neuron
populations encoding entities, we use the nLIF model with an exponential
synaptic kernel

$\dot{u}_{s,i}(t)=\frac{1}{\tau_{\mathrm{s}}}\sum_{j}W_{s,ij}\,\theta\left(t-t_{j}\right)\exp\left(-\frac{t-t_{j}}{\tau_{\mathrm{s}}}\right)\,,$
(4)

where $u_{s,i}$ is the membrane potential of the $i$th neuron of population
$s$, $\tau_{\mathrm{s}}$ the synaptic time constant and $\theta(\cdot)$ the
Heaviside function. A spike is emitted when the membrane potential crosses a
threshold value $u_{\mathrm{th}}$. $W_{s,ij}$ are synaptic weights from a pre-
synaptic neuron population, with every neuron $j$ emitting a single spike at
fixed time $t_{j}$ (Footnote 2A, bottom). This way, the coding in both
stimulus and embedding layers are consistent with each other and the embedding
spike times can be adjusted by changing synaptic weights $W_{s,ij}$. Eq. 4 can
be solved analytically

$u_{s,i}(t)=\sum_{t_{j}\leq
t}W_{s,ij}\left[1-\exp\left(-\frac{t-t_{j}}{\tau_{\mathrm{s}}}\right)\right]\,,$
(5)

which is later used to derive a learning rule for the embedding populations.

For relations, we use output neurons with a similar structure as proposed in
[38]. Each output neuron consists of a ’dendritic tree’, where branch $k$
evaluates the $k$th component of the spike pattern difference, i.e.,
$\|d\left(\boldsymbol{t}_{s},\boldsymbol{t}_{o}\right)-\boldsymbol{r}_{p}\|_{k}$,
and the tree structure subsequently sums over all contributions, giving
$\vartheta_{s,p,o}$ (Footnote 2A, top). This way, the components of
$\boldsymbol{r}_{p}$ become available to all entity populations, despite being
locally stored.

Different from ordinary feedforward or recurrent SNNs, the input is not given
by a signal that first has to be translated into spike times and is then fed
into the first layer (or specific input neurons) of the network. Instead,
inputs to the network are observed triples {$s$, $p$, $o$}, i.e., statements
that have been observed to be true. Since all possible entities are
represented as neuron populations, the input simply gates which populations
become active (Footnote 2A, orange), resembling a memory recall. During
training, such recalled memories are then updated to better predict observed
triples. Through this memory mechanism, an entity $s$ can learn about global
structures in the graph. For instance, since the representation of a relation
$p$ contains information about other entities that co-occur with it in
triples, {$m$, $p$, $n$}, $s$ can learn about the embeddings of $m$ and $n$
(and vice versa) – even if $s$ never appears with $n$ and $m$ in triples
together.

###  II-C Learning rules

To learn spike-based embeddings for entities and relations, we use a soft
margin loss

$\displaystyle l_{s,p,o}=$
$\displaystyle\log\left[1+\exp\left(\vartheta_{s,p,o}\cdot\eta_{s,p,o}\right)\right]\,,$
(6a) $\displaystyle
L(\boldsymbol{\vartheta},\boldsymbol{\eta})=\sum_{s,p,o}l_{s,p,o}\,,$ (6b)

where $\eta_{s,p,o}\in\\{1,-1\\}$ is a modulating teaching signal that
establishes whether an observed triple {$s$, $p$, $o$} is regarded as
plausible ($\eta_{s,p,o}=1$) or implausible ($\eta_{s,p,o}=-1$). This is
required to avoid collapse to zero-embeddings that simply score all possible
triples with $0$. In the graph embedding literature, implausible (negative)
examples are generated by corrupting plausible (positive) triples, i.e., given
a training triple {$s$, $p$, $o$}, either $s$ or $o$ are randomly replaced – a
procedure called ’negative sampling’ [22, 37].

The learning rules are derived by minimizing the loss via gradient descent. In
addition, as described in [1], we add a regularization term to the weight
learning rule that counters silent neurons (Simulation details). The gradient
for entities can be separated into a loss-dependent error and a neuron-model-
specific term

$\frac{\partial l_{s,p,o}}{\partial W_{s,ik}}=\frac{\partial
l_{s,p,o}}{\partial t_{s,i}}\frac{\partial t_{s,i}}{\partial W_{s,ik}}\,,$ (7)

while the gradient for relations only consists of the error $\frac{\partial
l_{s,p,o}}{\partial\boldsymbol{r}_{p}}$. The error terms are given by (Spike-
based model)

$\displaystyle\frac{\partial l_{s,p,o}}{\partial\boldsymbol{t}_{s}}$
$\displaystyle=\epsilon_{s,p,o}\cdot\mathrm{sign}\left(d_{\mathrm{A}}\left(\boldsymbol{t}_{s},\boldsymbol{t}_{o}\right)-\boldsymbol{r}_{p}\right)\,,$
(8a) $\displaystyle\epsilon_{s,p,o}$
$\displaystyle=\eta_{s,p,o}\cdot\sigma\left(\vartheta_{s,p,o}\cdot\eta_{s,p,o}\right)\,,$
(8b) $\displaystyle\frac{\partial l_{s,p,o}}{\partial\boldsymbol{t}_{o}}$
$\displaystyle=\frac{\partial
l_{s,p,o}}{\partial\boldsymbol{r}_{p}}=-\frac{\partial
l_{s,p,o}}{\partial\boldsymbol{t}_{s}}\,,$ (8c)

for SpikE and

$\displaystyle\frac{\partial l_{s,p,o}}{\partial\boldsymbol{t}_{s}}$
$\displaystyle=\epsilon_{s,p,o}\cdot\mathrm{sign}\left(\boldsymbol{t}_{s}-\boldsymbol{t}_{o}\right)\mathrm{sign}\left(d_{\mathrm{S}}\left(\boldsymbol{t}_{s},\boldsymbol{t}_{o}\right)-\boldsymbol{r}_{p}\right)\,,$
(9a) $\displaystyle\frac{\partial l_{s,p,o}}{\partial\boldsymbol{t}_{o}}$
$\displaystyle=-\frac{\partial l_{s,p,o}}{\partial\boldsymbol{t}_{s}}\,,$ (9b)
$\displaystyle\frac{\partial l_{s,p,o}}{\partial\boldsymbol{r}_{p}}$
$\displaystyle=-\epsilon_{s,p,o}\cdot\mathrm{sign}\left(d_{\mathrm{S}}\left(\boldsymbol{t}_{s},\boldsymbol{t}_{o}\right)-\boldsymbol{r}_{p}\right)\,,$
(9c)

for SpikE-S, where $\sigma(\cdot)$ is the logistic function.

The neuron-specific term can be evaluated using Eq. 5, resulting in (Spike-
based model)

$\frac{\partial t_{s,i}}{\partial
W_{s,ik}}=\frac{\tau_{\mathrm{s}}\theta\left(t_{s,i}-t_{k}\right)\left(e^{\left(t_{k}-t_{s,i}\right)/\tau_{\mathrm{s}}}-1\right)}{\sum_{t_{j}\leq
t_{s,i}}W_{s,ij}-u_{\mathrm{th}}}\,.$ (10)

For relations, all quantities in the update rule are accessible in the output
neuron. Apart from an output error, this is also true for the update rules of
nLIF spike times. Specifically, the learning rules only depend on spike times
– or rather spike time differences – pre-synaptic weights and neuron-specific
constants, compatible with recently proposed learning rules for SNNs [1, 4,
6]. Alternative losses like the (pairwise) hinge loss [37] can be used as well
to derive learning rules.

##  III Experiments

###  III-A Data

The proposed model is evaluated on an industrial automation demonstrator (Fig.
4), designed to capture the complexity of modern industrial automation systems
that combine operational technology (OT) components with an information
technology (IT) infrastructure. This convergence of OT and IT technology
promises massive improvements in the efficiency and flexibility of industrial
manufacturing systems, but comes with challenges like ensuring system
integrity and information security [39]. The OT side of our demonstrator has a
SIMATIC S7-1500 PLC at its core, connected via an Industrial Ethernet network
to multiple subsystems, such as a conveyor belt, industrial cameras or
multiple input-output modules connected to sensors. The PLC exposes the
internal state of some of these subsystems and sensors through a data
interface provided by an OPC UA [40] server. This is leveraged on the IT side
of the demonstrator, which includes a series of edge computing systems hosting
a number of applications, each of which regularly reads or writes data
variables on the OPC UA server corresponding to specific parts of the OT
system.

The complex set of interactions between the different elements of the
demonstrator, e.g., data accesses and network connections, can be naturally
represented in a KG and modeled using graph embedding algorithms. Such a model
allows us to evaluate the likelihood of observed system interactions and can
be used in anomaly detection tasks to expose unexpected behaviors of the
different system components, which may be indicative of a loss of integrity or
a cybersecurity incident.

Figure 4: Industrial automation demonstrator (left) used as a data source.
Both static engineering data as well as dynamic application activity and
network events (middle) are integrated in a KG (right).

Using such a demonstrator enables us to generate realistic data and benchmarks
in a flexible and controllable way [36]. For the following experiments, we use
a recording from the demonstrator system with some default network and
application activity, resulting in a KG with 3529 nodes, 11 node types, 2
applications, 21 IP addresses, 39 relation types, 360 network events and 472
data access events. We randomly split the graph with a ratio of 8/2 into
mutually exclusive training and test sets, resulting in 12399 training and
2463 test triples. Details of all experiments can be found in Simulation
details. For more information on the data generation process, see [36].

Figure 5: (A1) MRR during training for different models and data splits. The
MRR is evaluated for objects, i.e., given a triple {$s$, $p$, $o$}, $o$ is
ranked against all other possible objects. Training was repeated 10 times for
different random seeds. Shaded areas mark the 15th and 85th percentile. (A2)
Same as A1, but for subjects. (B1) Mean hits@k scores for objects as in A1.
Error bars mark the percentiles as in A1 and A2, and train and test data is
represented by striped and filled bars, respectively. (B2) Same as B1, but for
subjects. (C) Distribution of scores for positive and negative test triples.
As expected, positive examples get scores close to $0$, while negative
examples have bad scores, i.e., high mismatch between spike patterns.

###  III-B Model evaluation

In Footnote 2B, C, we showcase some of the learned spike embeddings for
entities and relations. We found that due to the temporal aspect of SNNs – and
the fixed time interval imposed by the stimulus layer – most embedding neurons
spike early. By evaluating scores over time in an event-based fashion,
implausible triples can be identified quickly (Footnote 2D), which is
beneficial when short reaction times are required, e.g., to raise an alarm.
This is not the case for TransE, where embeddings are always symmetric around
some baseline offset.

Next, we compare the performance of SpikE and TransE (and their symmetric
counterparts SpikE-S and TransE-S) on some traditional graph embedding
metrics. For performance evaluation, we use the mean reciprocal rank (MRR) and
hit-based metrics (hits@k) that are often used in the graph embedding
literature. In both cases, a plausible triple {$s$, $p$, $o$} is taken and all
alternative completions {$s$, $p$, $?$} (Fig. 5A1, B1) or {$?$, $p$, $o$}
(Fig. 5A2, B2) are scored and sorted. hits@k measures how frequently the
original triple {$s$, $p$, $o$} is under the k best scored triples, e.g.,
hits@1 measures how often it is the top ranked triple compared to all other
alternatives. The MRR averages the reciprocal of the ranks over the presented
data set, e.g., if a triple has the second best score (rank 2) it contributes
$1/2$ to the MRR.

All models achieve comparable results on these metrics, with a total MRR,
i.e., both cases combined, of: $0.843^{+0.007}_{-0.007}$,
$0.671^{+0.003}_{-0.003}$ (TransE); $0.872^{+0.006}_{-0.004}$,
$0.661^{+0.004}_{-0.004}$ (TransE-S); $0.824^{+0.009}_{-0.006}$,
$0.645^{+0.009}_{-0.007}$ (SpikE); $0.838^{+0.021}_{-0.020}$,
$0.587^{+0.040}_{-0.050}$ (SpikE-S), for train and test split (uncertainties
are given by the 15th and 85th percentile). To ensure that the algorithms are
also capable of separating plausible from implausible statements, we show the
pure triple scores both for the test data and negative examples generated from
it (Fig. 5C).

Figure 6: (A) An application reading data from the industrial automation
system. There are various ways how data variables accessed during training
(green) are related to other data variables in the system. For instance, they
might (gold) share internal structures documented in the engineering data,
(orange) be accessible from the same PLC or (red) only share type-based
similarities. (B) Accesses to various data variables sorted from top to bottom
according to their assigned implausibility (SpikE score). Colors are as in A.
Bars mark the 15th and 85th percentile for 10 different random seeds. In the
background, a second application is active that regularly reads the two data
variables with high uncertainty (orange), showing that the embedding of #app_1
also learns about the behavior of #app_2.

###  III-C Context-aware decision making

We further apply SpikE to an anomaly detection task, where an application
reads different data variables from the industrial system during training and
test time (Fig. 6A). Data events are sorted according to their SpikE score,
with the least plausible data access being on top (Fig. 6B). As expected, our
model utilizes contextual information available through the structure of the
KG to rank previously unseen data events, i.e., the less related data
variables are to the ones read during training, the higher they end up in the
ranking. For instance, SpikE clearly discerns whether the application accesses
variables that are exposed (Fig. 6B, green, gold and orange) or not exposed
(red) by the PLC.

##  IV Discussion

We present a model for spike-based graph embeddings, where nodes and relations
of a KG are mapped to spike times and spike time differences in a SNN,
respectively. This allows a natural transition from symbolic elements in a
graph to the temporal domain of SNNs, going beyond traditional data formats by
enabling the encoding of complex structures into spikes. Representations are
learned using gradient descent on an output cost function, which yields
learning rules that depend on spike times and neuron-specific variables.

In our model, input gates which populations become active and consequently
updated by plasticity. This memory mechanism allows the propagation of
knowledge through all neuron populations – despite the input being isolated
triple statements. After training, the learned embeddings can be used to
evaluate or predict arbitrary triples that are covered by the semantic space
of the KG. Moreover, learned spike embeddings can be used as input to other
SNNs, providing a native conversion of data into spike-based input – something
that is currently either done artificially by, e.g., mapping pixel values of
images to rates or latency codes [41, 42], or by restricting oneself to event-
based sensors that already provide data in a SNN-compatible format [43, 44].

The nLIF neuron model used in this work is well suited to represent
embeddings, but comes with the drawback of a missing leak term, i.e., the
neurons are modeled as integrators with infinite memory. This is critical for
neuromorphic implementations, where – most often – variations of the nLIF
model with leak are realized [30]. Gradient-based optimization of current-
based LIF neurons, i.e., nLIF with leak, that extend the results of [1] have
been demonstrated in [4, 6]. Since our model basically exchanges the cost
function and network architecture used in [1], these results can be directly
applied to our model as well, making it applicable to energy-efficient
neuromorphic implementations similar to the ones presented in [6]. In
contrast, output neurons take a simple, but function-specific form that is
different from ordinary nLIF neurons. Although realizable in neuromorphic
devices, we believe that alternative forms are possible. For instance, each
output neuron might be represented by a small forward network of spiking
neurons [45], or relations could be represented by learnable delays [46, 47,
48] or even remain constant (see Different simulation parameters and static
relations).

The presented results bridge the areas of graph analytics and SNNs, opening a
new direction in the ongoing endeavor of identifying how SNNs can encode
complex information [49]. In future work, this might be extended beyond the
single-spike coding scheme, enabling an efficient representation of static
graph data by fully utilizing the temporal domain of SNNs, e.g., by encoding
nodes as spike trains of individual neurons. Finally, such models promise
exciting and novel industrial applications of event-based neuromorphic
devices, e.g., as energy-efficient and flexible processing and learning units
for online evaluation of industrial graph data. Even though we only hint at
the industrial applicability here, more involved benchmarks are currently
being investigated in [36, 38].

## Acknowledgment

We thank Marcel Hildebrandt, Serghei Mogoreanu and Martin Ringsquandl for
helpful discussions, Johannes Frank for setting up the industrial automation
demonstrator as well as Steffen Lamparter, Robert Lohmeyer, Denis Krompaß,
Florian Büttner, Mark Buckley, Ulli Waltinger and Benno Blumoser for
supporting this work.

## References

  * [1] Hesham Mostafa  “Supervised learning based on temporal coding in spiking neural networks”  In _IEEE transactions on neural networks and learning systems_ 29.7 IEEE, 2017, pp. 3227–3235
  * [2] Friedemann Zenke and Surya Ganguli  “SuperSpike: Supervised Learning in Multilayer Spiking Neural Networks”  In _Neural computation_ 30.6 MIT Press, 2018, pp. 1514–1541
  * [3] Emre O Neftci, Hesham Mostafa and Friedemann Zenke  “Surrogate gradient learning in spiking neural networks: Bringing the power of gradient-based optimization to spiking neural networks”  In _IEEE Signal Processing Magazine_ 36.6 IEEE, 2019, pp. 51–63
  * [4] Iulia M Comsa et al.  “Temporal coding in spiking neural networks with alpha synaptic function”  In _IEEE International Conference on Acoustics, Speech and Signal Processing (ICASSP)_ , 2020, pp. 8529–8533  IEEE
  * [5] Saeed Reza Kheradpisheh and Timothée Masquelier  “S4NN: temporal backpropagation for spiking neural networks with one spike per neuron”  In _International Journal of Neural Systems_ 30.6, 2020, pp. 2050027
  * [6] Julian Göltz et al.  “Fast and deep: energy-efficient neuromorphic learning with first-spike times”  In _arXiv:1912.11443_ , 2020
  * [7] Emre Neftci et al.  “Event-driven contrastive divergence for spiking neuromorphic systems”  In _Frontiers in neuroscience_ 7 Frontiers, 2014, pp. 272
  * [8] Mihai A. Petrovici et al.  “Stochastic inference with spiking neurons in the high-conductance state”  In _Phys. Rev. E_ 94 American Physical Society, 2016, pp. 042312
  * [9] Dominik Dold et al.  “Stochasticity from function — Why the Bayesian brain may need no noise”  In _Neural Networks_ 119, 2019, pp. 200–213
  * [10] Guillaume Bellec et al.  “Long short-term memory and learning-to-learn in networks of spiking neurons”  In _Advances in Neural Information Processing Systems_ , 2018, pp. 787–797
  * [11] Guillaume Bellec et al.  “A solution to the learning dilemma for recurrent networks of spiking neurons”  In _Nature communications_ 11.3625, 2020
  * [12] Sander M Bohte, Joost N Kok and Johannes A La Poutré  “SpikeProp: backpropagation for networks of spiking neurons.”  In _ESANN_ , 2000, pp. 419–424
  * [13] Dongsung Huh and Terrence J Sejnowski  “Gradient Descent for Spiking Neural Networks”  In _Advances in Neural Information Processing Systems 31_ , 2018, pp. 1433–1443
  * [14] Timo C Wunderlich and Christian Pehle  “EventProp: Backpropagation for Exact Gradients in Spiking Neural Networks”  In _arXiv:2009.08378_ , 2020
  * [15] Benjamin Cramer, Yannik Stradmann, Johannes Schemmel and Friedemann Zenke  “The Heidelberg Spiking Data Sets for the Systematic Evaluation of Spiking Neural Networks”  In _IEEE Transactions on Neural Networks and Learning Systems_ IEEE, 2020
  * [16] Sören Auer et al.  “Dbpedia: A nucleus for a web of open data”  In _The semantic web_ Springer, 2007, pp. 722–735
  * [17] Kurt Bollacker et al.  “Freebase: a collaboratively created graph database for structuring human knowledge”  In _Proceedings of the 2008 ACM SIGMOD international conference on Management of data_ , 2008, pp. 1247–1250
  * [18] Amit Singhal  “Introducing the knowledge graph: things, not strings, May 2012”  In _URL http://googleblog. blogspot. ie/2012/05/introducing-knowledgegraph-things-not. html_ , 2012
  * [19] Dan Brickley, Ramanathan V Guha and Andrew Layman  “Resource description framework (RDF) schema specification”  In _Technical report, W3C._ , 1999
  * [20] Maximilian Nickel, Kevin Murphy, Volker Tresp and Evgeniy Gabrilovich  “A review of relational machine learning for knowledge graphs”  In _Proceedings of the IEEE_ 104.1 IEEE, 2015, pp. 11–33
  * [21] William L Hamilton, Rex Ying and Jure Leskovec  “Representation learning on graphs: Methods and applications”  In _IEEE Data Engineering Bulletin_ , 2017
  * [22] Daniel Ruffinelli, Samuel Broscheit and Rainer Gemulla  “You CAN teach an old dog new tricks! on training knowledge graph embeddings”  In _International Conference on Learning Representations_ , 2019
  * [23] Kathleen E Hamilton, Neena Imam and Travis S Humble  “Community detection with spiking neural networks for neuromorphic hardware”  In _Proceedings of the Neuromorphic Computing Symposium_ , 2017, pp. 1–8
  * [24] Kathleen E Hamilton and Catherine D Schuman  “Towards adaptive spiking label propagation”  In _Proceedings of the International Conference on Neuromorphic Systems_ , 2018, pp. 1–8
  * [25] Kathleen E Hamilton et al.  “Neural networks and graph algorithms with next-generation processors”  In _2018 IEEE International Parallel and Distributed Processing Symposium Workshops (IPDPSW)_ , 2018, pp. 1194–1203  IEEE
  * [26] Catherine D Schuman et al.  “Shortest path and neighborhood subgraph extraction on a spiking memristive neuromorphic implementation”  In _Proceedings of the 7th Annual Neuro-inspired Computational Elements Workshop_ , 2019, pp. 1–6
  * [27] Abdullahi Ali and Johan Kwisthout  “A spiking neural algorithm for the Network Flow problem”  In _arXiv:1911.13097_ , 2019
  * [28] Kathleen E Hamilton, Tiffany M Mintz and Catherine D Schuman  “Spike-based primitives for graph algorithms”  In _arXiv:1903.10574_ , 2019
  * [29] Bill Kay, Prasanna Date and Catherine Schuman  “Neuromorphic graph algorithms: Extracting longest shortest paths and minimum spanning trees”  In _Proceedings of the Neuro-inspired Computational Elements Workshop_ , 2020, pp. 1–6
  * [30] Chetan Singh Thakur et al.  “Large-scale neuromorphic spiking array processors: A quest to mimic the brain”  In _Frontiers in neuroscience_ 12 Frontiers, 2018, pp. 891
  * [31] Kaushik Roy, Akhilesh Jaiswal and Priyadarshini Panda  “Towards spike-based machine intelligence with neuromorphic computing”  In _Nature_ 575.7784 Nature Publishing Group, 2019, pp. 607–617
  * [32] Mike Davies  “Benchmarks for progress in neuromorphic computing”  In _Nature Machine Intelligence_ 1.9 Nature Publishing Group, 2019, pp. 386–388
  * [33] Marcel Hildebrandt et al.  “Configuration of industrial automation solutions using multi-relational recommender systems”  In _Joint European Conference on Machine Learning and Knowledge Discovery in Databases_ , 2018, pp. 271–287  Springer
  * [34] Martin Ringsquandl et al.  “On event-driven knowledge graph completion in digital factories”  In _2017 IEEE International Conference on Big Data (Big Data)_ , 2017, pp. 1676–1681  IEEE
  * [35] Martin Ringsquandl et al.  “Semantic-guided feature selection for industrial automation systems”  In _International Semantic Web Conference_ , 2015, pp. 225–240  Springer
  * [36] Josep Soler Garrido, Dominik Dold and Johannes Frank  “Machine learning on knowledge graphs for context-aware security monitoring”  In _IEEE International Conference on Cyber Security and Resilience (IEEE-CSR)_ , 2021  IEEE
  * [37] Antoine Bordes et al.  “Translating embeddings for modeling multi-relational data”  In _Advances in neural information processing systems_ , 2013, pp. 2787–2795
  * [38] Dominik Dold and Josep Soler Garrido  “An energy-based model for neuro-symbolic reasoning on knowledge graphs”  In _unpubl._ , in prep.
  * [39] Richard Paes, David C Mazur, Bruce K Venne and Jack Ostrzenski  “A Guide to Securing Industrial Control Networks: Integrating IT and OT Systems”  In _IEEE Industry Applications Magazine_ 26.2 IEEE, 2019, pp. 47–53
  * [40] Wolfgang Mahnke, Stefan-Helmut Leitner and Matthias Damm  “OPC unified architecture”  Springer Science & Business Media, 2009
  * [41] Michael Pfeiffer and Thomas Pfeil  “Deep learning with spiking neurons: opportunities and challenges”  In _Frontiers in neuroscience_ 12 Frontiers Media SA, 2018
  * [42] Catherine D Schuman, James S Plank, Grant Bruer and Jeremy Anantharaj  “Non-traditional input encoding schemes for spiking neuromorphic systems”  In _2019 International Joint Conference on Neural Networks (IJCNN)_ , 2019, pp. 1–10  IEEE
  * [43] Matthew Evanusa and Yulia Sandamirskaya  “Event-based attention and tracking on neuromorphic hardware”  In _Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition Workshops_ , 2019, pp. 0–0
  * [44] Riccardo Massa, Alberto Marchisio, Maurizio Martina and Muhammad Shafique  “An efficient spiking neural network for recognizing gestures with a dvs camera on the loihi neuromorphic processor”  In _The 2020 International Joint Conference on Neural Networks (IJCNN)_ , 2020  IEEE
  * [45] Panayiota Poirazi, Terrence Brannon and Bartlett W Mel  “Pyramidal neuron as two-layer neural network”  In _Neuron_ 37.6 Elsevier, 2003, pp. 989–999
  * [46] Paul W Wright and Janet Wiles  “Learning transmission delays in spiking neural networks: A novel approach to sequence learning based on spike delay variance”  In _The 2012 International Joint Conference on Neural Networks (IJCNN)_ , 2012, pp. 1–8  IEEE
  * [47] Xiangwen Wang, Xianghong Lin and Xiaochao Dang  “A delay learning algorithm based on spike train kernels for spiking neurons”  In _Frontiers in Neuroscience_ 13 Frontiers, 2019, pp. 252
  * [48] Malu Zhang et al.  “Supervised Learning in Spiking Neural Networks with Synaptic Delay-Weight Plasticity”  In _Neurocomputing_ Elsevier, 2020
  * [49] Friedemann Zenke et al.  “Visualizing a joint future of neuroscience and neuromorphic engineering”  In _Neuron_ 109.4 Elsevier, 2021, pp. 571–575

## Supplementary Information

###  IV-A Spike-based model

#### Spike time gradients

The gradients for $d_{\mathrm{S}}$ can be calculated as follows

$\frac{\partial l_{s,p,o}}{\partial\boldsymbol{t}_{s}}=\frac{\partial
l_{s,p,o}}{\partial\vartheta_{s,p,o}}\frac{\partial\vartheta_{s,p,o}}{\partial
d_{\mathrm{S}}}\frac{\partial d_{\mathrm{S}}}{\partial\boldsymbol{t}_{s}}\,,$
(11)

with

$\displaystyle\frac{\partial l_{s,p,o}}{\partial\vartheta_{s,p,o}}$
$\displaystyle=\eta_{s,p,o}\cdot\sigma\left(\vartheta_{S,p,o}\cdot\eta_{s,p,o}\right)\,,$
(12a) $\displaystyle\frac{\partial\vartheta_{s,p,o}}{\partial d_{\mathrm{S}}}$
$\displaystyle=\mathrm{sign}\left(d_{\mathrm{S}}\left(\boldsymbol{t}_{s},\boldsymbol{t}_{o}\right)-\boldsymbol{r}_{p}\right)\,,$
(12b) $\displaystyle\frac{\partial
d_{\mathrm{S}}}{\partial\boldsymbol{t}_{s}}$
$\displaystyle=\mathrm{sign}\left(\boldsymbol{t}_{s}-\boldsymbol{t}_{o}\right)\,.$
(12c)

All other gradients can be obtained similarly.

#### Weight gradients

The spike times of nLIF neurons can be calculated analytically by setting the
membrane potential equal to the spike threshold $u_{\mathrm{th}}$, i.e.,
$u_{s,i}(t^{*})\overset{!}{=}u_{\mathrm{th}}$:

$t^{*}=\tau_{\mathrm{s}}\ln\bigg{(}\underbrace{\frac{\sum_{t_{j}\leq
t^{*}}W_{s,ij}\,e^{t_{j}/\tau_{\mathrm{s}}}}{\sum_{t_{j}\leq
t^{*}}W_{s,ij}-u_{\mathrm{th}}}}_{=T^{*}}\bigg{)}\,.$ (13)

In addition, for a neuron to spike, three additional conditions have to be met
[1]:

  * •

the neuron has not spiked yet,

  * •

the input is strong enough to push the membrane potential above threshold,
i.e.,

$\sum_{t_{j}\leq t^{*}}W_{s,ij}>u_{\mathrm{th}}\,,$ (14)

  * •

the spike occurs before the next causal pre-synaptic spike $t_{c}$, i.e.,
there is no other pre-synaptic spike influencing $t^{*}$,

$t^{*}<t_{c}\,.$ (15)

From this, we can calculate the gradient

$\displaystyle\frac{\partial t^{*}}{\partial W_{s,ik}}$
$\displaystyle=\frac{\tau_{\mathrm{s}}}{T^{*}}\cdot\frac{\partial
T^{*}}{\partial W_{s,ik}}$ (16a)
$\displaystyle=\frac{\tau_{\mathrm{s}}\theta\left(t^{*}-t_{k}\right)}{T^{*}}\bigg{[}\frac{e^{t_{k}/\tau_{\mathrm{s}}}}{\sum_{t_{j}\leq
t^{*}}W_{s,ij}-u_{\mathrm{th}}}$ $\displaystyle-\frac{T^{*}}{\sum_{t_{j}\leq
t^{*}}W_{s,ij}-u_{\mathrm{th}}}\bigg{]}$ (16b)
$\displaystyle=\frac{\tau_{\mathrm{s}}\theta\left(t^{*}-t_{k}\right)}{\sum_{t_{j}\leq
t^{*}}W_{s,ij}-u_{\mathrm{th}}}\left[\exp\left(\frac{t_{k}-t^{*}}{\tau_{\mathrm{s}}}\right)-1\right]\,,$
(16c)

where we used that $T^{*}=\exp\left(\frac{t^{*}}{\tau_{\mathrm{s}}}\right)$.

###  IV-B Simulation details

Data, code and further examples using the Countries data set are available on
https://github.com/dodo47/SpikE.

#### Regularization of weights

To ensure that all neurons in the embedding populations spike, we use the same
regularization term $L_{\delta}$ as [1]

$L_{\delta}=\begin{cases}\sum_{s,i}\delta\cdot\left(u_{\mathrm{th}}-w_{s,i}\right)&\text{if
}w_{s,i}\leq u_{\mathrm{th}}\,,\\\ 0&\text{otherwise}\,,\end{cases}$ (17)

with $w_{s,i}=\sum_{j}W_{s,ij}$.

#### Software implementation

Simulations were done using Python 3.7.7 and PyTorch 1.6.0. For gradient
updates, we use the Adagrad optimizer with $\epsilon=10^{-10}$. The loss is
averaged per mini-batch.

#### Experiments

We compute filtered metrics, i.e., where other triples that are also known to
be true are removed from the ranking list. For SpikE(-S), stimulating spikes
are randomly initialized from a uniform distribution in the interval
$[t_{0},t_{\mathrm{max}}]$ and weights from a normal distribution
$\mathcal{N}\left(0.2,1.0\right)$. Both for TransE(-S) and SpikE(-S), other
embeddings are randomly initialized from a normal distribution
$\mathcal{N}\left(0.0,1.0\right)$. For SpikE-S, we reduce the learning rate
after 36 epochs to improve convergence. $u_{\mathrm{th}}=1$ in all cases. For
TransE we use the same loss function as for SpikE. The remaining simulation
parameters are given in Table I.

TABLE I: Simulation parameters.

TransE(-S) SpikE SpikE-S dimension 20 20 20 learning rate 0.1 1.0 1.0 $|$ 0.1
batch size 50 50 50 neg. samples 2$\times$2 2$\times$2 2$\times$2 L2 reg.
0.0001 0 0 stim. neurons - 40 40 $\tau_{\mathrm{s}}$ - 0.5 0.5
$[t_{0},t_{\mathrm{max}}]$ - $[-1,1]$ $[-3,3]$ $\delta$ - 0.01 0.01

For the results shown in Fig. 6, we use a mini-batch size of 100, dimension of
12 and $\delta=0.001$. MRR, hits@k and general scores for these parameters are
shown in Different simulation parameters and static relations.

###  IV-C Gating with parrot neurons

Gating either as subject or object of an embedding population can be realized
using two populations of parrot neurons that immediately transmit their input
and are gated instead. This further allows the evaluation of relations that
target the same subject and object population.

###  IV-D Synchronizing subject and object population

If an entity is represented by distinct subject $s$ and object $o$
populations, these representations will differ after training despite
representing the same entity. By adding triples of the form {$s$,
#isIdenticalTo, $o$} and keeping $\boldsymbol{r}_{\mathrm{isIdenticalTo}}=0$,
further alignment can be enforced (Fig. 7).

Figure 7: (A) MRR during training for TransE (blue), TransE with separate
subject and object populations (gray) and TransE with separate populations and
additional triple statements that enforce alignment (violet). (B) Strong
alignment of subject and object populations can be observed when new triples
are added during training. (C) Apart from the hits@1 score, adding alignment-
preferring triples improves the performance.

###  IV-E Different simulation parameters and static relations

Figure 8: Same experiment as in Fig. 5, but for a mini-batch size of 100,
dimension of 12 and $\delta=0.001$ (blue, red). Training still works if only
node embeddings $\boldsymbol{t}_{x}$ are learned (yellow), i.e., relation
embeddings $\boldsymbol{r}_{x}$ are kept constant, but not vice versa, see
gray dashed lines in A marking the best reached training MRR for that case.
This highlights the importance of learning the spike times of the neural
populations encoding entities in SpikE.


# Towards Task-Specific Modular Gripper Fingers: Automatic Production of
Fingertip Mechanics

Johannes Ringwald, Samuel Schneider, Lingyun Chen, Dennis Knobbe, Lars
Johannsmeier,
Abdalla Swikir and Sami Haddadin This work was funded by the German Research
Foundation (DFG, Deutsche Forschungsgemeinschaft) as part of Germany’s
Excellence Strategy – EXC 2050/1 – Project ID 390696704 – Cluster of
Excellence “Centre for Tactile Internet with Human-in-the-Loop” (CeTI) of
Technische Universität Dresden. The authors gratefully acknowledge the funding
of the Lighthouse Initiative KI.FABRIK Bayern by StMWi Bayern (KI.FABRIK
Bayern Phase 1: Aufbau Infrastruktur and KI.Fabrik Bayern Forschungs- und
Entwicklungsprojekt, grant no. DIK0249). We also gratefully acknowledge the
funding of the Lighthouse Initiative Geriatronics by LongLeif GaPa gGmbH
(Project Y).The authors are with the Chair of Robotics and Systems
Intelligence and Munich Institute of Robotics and Machine Intelligence,
Technical University Munich (TUM), D-80797 Munich, Germany e-mail:
<EMAIL_ADDRESS>Please note that S. Haddadin has a potential
conflict of interest as a shareholder of Franka Emika GmbH.⋆ This work has
been submitted to the IEEE for possible publication. Copyright may be
transferred without notice, after which this version may no longer be
accessible.

###### Abstract

The number of sequential tasks a single gripper can perform is significantly
limited by its design. In many cases, changing the gripper fingers is required
to successfully conduct multiple consecutive tasks. For this reason, several
robotic tool change systems have been introduced that allow an automatic
changing of the entire end-effector. However, many situations require only the
modification or the change of the fingertip, making the exchange of the entire
gripper uneconomic. In this paper, we introduce a paradigm for automatic task-
specific fingertip production. The setup used in the proposed framework
consists of a production and task execution unit, containing a robotic
manipulator, and two 3D printers - autonomously producing the gripper fingers.
It also consists of a second manipulator that uses a quick-exchange mechanism
to pick up the printed fingertips and evaluates gripping performance. The
setup is experimentally validated by conducting automatic production of three
different fingertips and executing grasp-stability tests as well as multiple
pick- and insertion tasks, with and without position offsets - using these
fingertips. The proposed paradigm, indeed, goes beyond fingertip production
and serves as a foundation for a fully automatic fingertip design, production
and application pipeline - potentially improving manufacturing flexibility and
representing a new production paradigm: tactile 3D manufacturing.

##  I Introduction

Most conditions of manipulation tasks in industrial production setups can be
precisely controlled, like initial positions and orientations of manipulation
objects which should be processed. Despite these controllable conditions,
performing tasks with multi-degree of freedom (DoF) hands is still a complex
assignment and a subject of basic research. Moreover, the performance of soft
grippers depends on the scenario considered. For example, robustness problems
can arise if objects with sharp edges must be grasped with high grasping
forces. Accordingly, most industrial assembly tasks are still performed by
two- or three-finger parallel grippers. To enable robust grasping and
manipulation of defined objects, the fingers of these grippers must be
manually designed, produced, tested and iterated until reaching a satisfactory
performance. This adaptation process is not only very laborious and time-
consuming, but also requires a high level of design experience in this field
[1]. Therefore, the number of assembly objects and manipulation scenarios that
can be handled is limited by the time a designer needs to adapt a finger to a
specific application. This makes the assembly line setup in-flexible, since
any changes, like tool-changing, finger adaption etc. are very time consuming
and therefore costly. Accordingly, assembly or production lines are usually
setup for a few product types, which are produced in masses over a longer time
period (month/years). All integrated robots conduct only one specific task
with one specialized tool or finger design, which increases the required
number of robots for a designated assembly scenario significantly.
A flexible production of smaller batch sizes requires a smaller adaption time
of the setup to a new product (minutes/hours). Therefore, a significantly
shorter - ideally fully automatized - gripper finger design, production and
iteration process would be needed.

Figure 1: Automatic fingertip production and task execution based on a given
fingertip design and finger base set - using two robot-arms and two 3D
printers.

Figure 2: Presented testbed divided into a production and a task-execution
unit. The production unit conducts the extension of 3D printed standard
finger-bases with custom fingertip elements by: 1. extraction of two finger-
bases from corresponding finger-base magazines by a robot-arm. 2. Insertion
and locking of these finger-bases to finger-holder frames, stationary placed
on the build-plate of two 3D printers. 3. Printing of custom fingertips on top
of pre-produced finger-bases. 4. The extended finger is picked up by the
robot-arm and inserted into the magazines of the quick-finger-exchange system.
5. Using the QFE system, the gripper fingers are picked up by the task
execution unit. To conduct the finger testing tasks an IoT-Box is used, which
provides pick and place tasks for three different objects: key, Ethernet-
cable, battery.

Several automatic approaches for robot finger design adaptation have been
introduced to solve the aforementioned problems [2, 3, 4, 5, 6, 7, 8, 9]. One
aspect of this adaptation process concerns the finger surface design which
majorly affects the ability to robustly perform stable grasps and manipulation
tasks. Different approaches have been introduced to optimize the gripper
finger morphology and geometry based on a given set of objects [10, 11, 12,
13, 1, 14, 15, 16]. Despite all the efforts to automate the gripper finger
design, the set of tasks a robot manipulator can perform is still limited to
its mounted fingers. Therefore, different tool-changing systems for robotic
applications have been developed [17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27,
28, 29, 30, 31, 32]. While most of these systems focus on exchanging the
entire end-effector, some of them focus specifically on replacing single
fingers [17, 31, 20], or modifying the finger configuration [32].
Unfortunately, none of the aforementioned work provides a fully automated
process for the gripper finger production and exchange. In other words, the
fingers must be replaced manually during an ongoing manipulation process.

Motivated by the above limitations, we introduce a fully automated setup for
gripper finger production and exchange. In particular, by integrating a
collaborative robot - the Panda arm - with two 3D printers, it was possible to
automate the production of a predefined set of fingertips. Furthermore, we
introduce a passive quick-finger-exchange system that allows the robot to
automatically change the used finger-pair during a manipulation task. By
combining the automatic fingertip production and the quick-finger-exchange
system, the time required to adapt to a new assembly task dramatically
decreases. E.g., the automatic production of new fingertips using a standard
finger base reduces the production time of new gripper fingers significantly
(minutes instead of hour).
The number of assembly steps a single robot can perform during a new
production/assembly task increases, since one robot can select and change its
gripper-finger automatically during the entire assembly process. Accordingly
our approach makes it possible to realize an efficient and flexible small
batch production/assembly process, while minimizing the required time, labor
and infrastructure required for the assembly - like the number of robots
needed for the task. Fig.1 illustrates this automatic process. Moreover, the
proposed approach will serve as a first step and foundation for a fully
automated task-specific finger design, production, and application pipeline,
which will enable a robot to identify its own fingertips and, potentially,
provide the base for a novel production paradigm: tactile 3D manufacturing.

The paper is organized as follows. In Sec. II, we describe the production
processes as well as the quick-finger-exchange mechanism. Then, in Sec. III,
we demonstrate the application and effectiveness of the proposed approach
through experiments. Finally, we discuss our results and provide a conclusion
in Sec. IV.

##  II Production and Task Execution Unit

The proposed setup is divided into a production unit and a task execution
unit, see Fig.2. The production unit performs all the required steps to
automatically build a task-specific parallel gripper fingertip design onto a
pre-defined finger-base. The task execution unit uses these fingers to conduct
a defined set of tasks. Those fingers can be automatically changed during the
robot operation using a quick-exchange system. Accordingly, the fingers the
production unit provides can be collected to a finger library and used
multiple times by the task-execution unit - depending on the currently needed
fingertip geometry. This allows the same robots of an assembly line/setup to
change their fingers automatically in seconds and adapt to a new product
quickly.
Therefor, our specifically designed 3D-printing based production setup has the
following advantages compared to a traditional non-automated manually
conducted gripper finger production process: (1) The presented setup is able
to react to new tasks and required finger geometries quickly since no manual
work or other production services are required. (2) This level of automation
safes time consuming and potentially costly labor. (3) Since no regular worker
needs to operate the setup, our approach is easily scalable to an arbitrary
number of production units without any limitations due to skilled worker
shortage. (4) Our setup can serve as a base framework for a fully automatic
gripper finger design, production and task execution pipeline.

Figure 3: A flowchart of the fingertip production cycle, described in Section
II-A.

###  II-A Production Unit

In order to produce a customized finger-pair, the following steps must be
conducted (see Fig.2 and Fig.3 ). First, robot-A picks a finger-base from the
finger-base111The finger-bases have been pre-produced by 3D printing. storage
magazine-A, inserts it into the finger-holder of printer-A and locks the
finger-holder to prevent uplift movements of the inserted finger-base. This
enables the 3D printing-pipeline to print a pre-defined fingertip on top of
the inner finger-base surface222The used material for finger-base and
fingertip is PLA. (see Fig.2). After the printing process is finished, the
finger is picked up again by robot-A and inserted into a designated quick-
finger-exchange magazine. After the printing process of the first finger is
started at printer-A, the production process of the second finger is triggered
in parallel (see Fig.3). Accordingly, robot-A picks another finger-base from
finger-base magazine-B, inserts it into printer-B and places the finger next
to the first finger into the designated quick-exchange finger magazine after
the printing process is finished. The customized finger-pair can now be taken
from the quick-finger-exchange magazine by robot-B, to conduct the designated
task.

The fingertips of these fingers are designed manually, mostly based on the
design guidelines of Greg Causey for gripper-finger geometries [33].
Accordingly, we mimiced the contour of the manipulation objects to maximize
form-closure and closure force distribution. But contrary to Causey’s
recommendations we incorporated additional V shape chamfers for the key and
battery fingertips to better compensate potential positioning errors.

Performing the previously mentioned production cycle requires six software
modules, illustrated in Fig.4 and described as follows.

#### Process Coordination

The process control unit runs on a central host computer and integrates all
the software modules and communication interfaces of the used devices. The
communication between 3D printers and robot arms is conducted via Ethernet
within a local network. Based on this setup, the process control unit controls
and coordinates all the production and task execution steps.

Figure 4:  Software pipeline running on five different device types: a device
control PC, two robot-control computers, and master-controllers, as well as
two raspberry pi’s and 3D printers. The device control PC coordinates all
production and task-execution steps. The fingertip CAD model is converted to
STL-format and then pre-processed to align the fingertips with the finger-
holder on the 3D printer build-plate. A slicer generates the gcode based on
these processed STL files, which is additionally modified to avoid collisions
between print-head and finger-holder. The processed gcode-file is uploaded to
a raspberry pi 4b running OcotPrint via the python OctoPrint API OctoRest. The
Raspberry pi’s together with OctoPrint are enabling the communication between
the process control PC and the 3D printers. The two panda robot-arms used to
conduct the production and task-execution operations are controlled by a
customized robot-control-framework and the firmware running on the panda
master controller. The process control unit is calling the functionality from
this robot-control-framework.

#### STL Pre-Processing

After converting the CAD model of the custom-designed fingertip to an STL
format (Standard Triangle Language), an STL pre-processing unit re-orients and
automatically re-positions the model design onto the top of the finger-base
(see Fig.5). Each custom-designed fingertip might have a different global
orientation and position relative to the printer coordinate system and
correspondingly the finger holder. To place them at the desired position, two
transformation steps are performed. First, the required re-orientations are
performed manually333Note that this manual re-orientation is not a part of our
automatic process, rather it should be done during the design of the CAD
model. once for each fingertip-model. To do so, the original position
$(v_{x},v_{y},v_{z})^{T}$ of the model is re-oriented to the new position
$(v_{x_{rotate}},v_{y_{rotate}},v_{z_{rotate}})^{T}$ by multiplying it by a
rotation matrix[34].

Then the boundary box of the rotated model can be acquired by traversing all
the vertices, represented with
$v_{x_{min}},v_{x_{max}},v_{y_{min}},v_{y_{max}},v_{z_{min}},v_{z_{max}}$
indicating the minimum and maximum size boundaries. These boundaries are
compared with a virtual boundary box of size $b_{x},b_{y}$ representing the
finger-base print-area (see Fig.5). The position of each vertex after
translation is calculated as follows:

$\displaystyle v_{x_{trans}}$
$\displaystyle=v_{x_{rotate}}-(v_{x_{max}}-v_{x_{min}})/2-v_{x_{min}}$
$\displaystyle v_{y_{trans}}$
$\displaystyle=v_{y_{rotate}}-v_{y_{max}}+b_{y}/2$ $\displaystyle
v_{z_{trans}}$ $\displaystyle=v_{z_{rotate}}-v_{z_{min}}.$

The virtual boundary box itself is then manually positioned relative to the
build-plate. This step has to be conducted only one time for each printer. All
custom fingertips which fit into the boundary-box will be automatically
centered and aligned to the front-edge of the finger-base as described.

The global z-offset is conducted via the slicer parameter to adapt the
distance between the nozzle and finger-base independent of the STL-processing.

Figure 5:  STL pre-processing pipeline to re-orient (A), re-position (B), and
center the fingertip relative to a virtual boundary box (C)/(D).

#### Automatic Slicing

After the STL-files have been pre-processed, we use PrusaSlicer to generate
the gcode needed to perform the printing process [35]. PrusaSlicer provides
command-line utility which can be interfaced with our process control unit.
Important parameters like infill-density, layer-height, build-plate adhesion
options or post-print-commands are configured via this interface.

#### Gcode Editing

The generated gcode is adapted to avoid a possible collision between the
finger-holder and print-head during the homing operations at the beginning of
each print. Additionally the mesh bed leveling operations needed to be
deactivated, via this process, to avoid collisions.

#### OctoPrint

Once the gcode is ready, it can be uploaded to the OctoPrint-Server via the
python OctoRest API [36]. OctoPrint [37] is a browser based remote control and
monitoring software for desktop 3D-printing applications. The software is
installed and running via OctoPi on a raspberry pi 4b - enabling access to the
printer via the local Ethernet network. In this setup, the process control
unit can upload the generated gcode, give the order to print the fingertip,
and monitor the state of the printing process.

#### Robot-arm Operation Control

The process control unit commands all required robot pick and place operations
of the production as well as the task execution unit. It uses a custom
Python/C++ framework. The framework was originally developed to enable complex
manipulation task learning [38, 39]. It provides different skills like move to
contact or object insertion to conduct these robot operations via a python
interface. It is executed on an Intel NUC computer, which interfaces the
master-controller of the used panda robots with the local network.

###  II-B Task-Execution-Unit

The task execution unit contains another panda robot arm, and is equipped with
a quick-finger-exchange mechanism, three quick-exchange magazines, an IoT-Box
[40] and a grasp-stability-test setup. The IoT-Box serves as a test station to
evaluate the performance of the pick and insertion tasks with three different
objects: a key, an Ethernet cable, and a battery. Different pick and insertion
strategies are required to successfully conduct the tasks for these objects,
enabling a more extensive evaluation of the presented approach.

Figure 6: Finger change process: (1) Gripper positioning above the trigger-
tongues of the QFE magazine, (2) Establishing contact and force application to
the QFE magazine. (3) Trigger-tongues of the QFE magazine push the spring pre-
tensioned secure stone up. Then the gripper-finger-interfaces move to the
center until the QFE-tongue of the finger-bases is fully inserted into the
QFE-mechanism. (4) The gripper moves up and releases the secure-stone and
locks the fingers-bases.

#### Quick-Finger-Exchange-System

The presented quick-finger-exchange (QFE) system enables the passive change of
parallel gripper fingers during robot operations and is compact enough to be
mounted to the finger-interfaces of a panda gripper. The mechanism uses a
form-closure based locking-system - similar to a door-locking-mechanisms (see
Fig.6). A secure stone holds the corresponding tongue of the finger-base in
position.

The finger-bases are stored and positioned within the QFE magazines. In order
to receive the fingers, the following process is conducted: (1) The QFE units
of the gripper are positioned above the trigger tongues of the QFE magazine.
(2) This allows the insertion of the trigger tongues into corresponding
magazine tongue slits of the QFE elements. Once inserted, the gripper moves to
contact and pushes the gripper towards the table plate. This pushes the secure
stone of the QFE element up, since the transition levers transfer the QFE
magazine tongue contact to the spring pre-tensioned secure stone. (3) Once the
secure stone is pushed up, the gripper can close which inserts the finger-base
QFE tongues into the corresponding opening of the QFE unit. (4) Are the
finger-base tongues inserted, they can be secured by re-leaving the secure-
stone via an upwards move of the gripper. A spring pushes the secure stone
into the corresponding groove of the finger-base tongue and holds the finger
via form-closure.

##  III Experiments

The production as well as the task execution unit have been evaluated
experimentally444The experiments have been documented in the accompanying
video..

#### Production Unit

The production of the fingertips was evaluated by two kind of experiments:
(1) The complete production cycle was conducted for each custom-designed
fingertip - starting with finger-base pick from the finger magazines and
ending by inserting the task-specific finger-pairs into the QFE magazines. The
printing times of each fingertip have been:

  * •

Key-fingertip: 5 min and 37 sec

  * •

Ethernet-fingertip: 11 min and 16 sec

  * •

Battery-fingertip: 9 min and 52 sec

These results show that a fast and fully automatic production of new gripper
fingers is possible - potentially enabling a quick adaption of fingers to a
new problem.
(2) To evaluate the fingertip production consistency and robustness, the
printing process of finger-tip A555The measurements of the other finger-types
have not been analysed. (manipulation object: key) was conducted 15 times with
each printer - resulting overall in 30 printing trials. The geometrical
dimensions of designated points of the finger have been measured via a
caliper. Mean, variance and minimum/maximum values of the measurements for
each point have been calculated (see Finger-Geometry-Data ). The geometrical
variation is significantly different for finger-base and finger-tip. The
finger-base measurements show the smallest variance and absolute min/max
differences of 0,15mm to 0,19mm. The finger-tips show a measurement variance
and absolute value difference of 0,11mm-0,79mm which is many times higher
compared to the finger-base. This is plausible, since the finger-base is hold
in position within the finger-holder by form-closure during the printing
process. This results in a small gap between finger-base and finger-holder
sidewalls, giving room to potential small movements of the finger-base during
the printing process.
Nevertheless, the analysis shows that the geometrical variations are small
relative to the absolute finger dimensions.
Apart from this geometrical analysis, the first layer of all sample-prints
show a slightly rough border, which seem not to influence the grasping
performance. Also three specimens showed small 3D printing failures
666Filament parts on the fingerbase body. One specimen had this failure within
the grasping area of the fingertip.

#### Task Execution Unit

The produced fingers and the presented QFE system are further evaluated by
performing pick and insert operations using the described IoT-Box as well as a
grasp stability test. Ten different trials have been conducted. One trial
contains the following series of steps and experiments for each finger-type
and corresponding manipulation object key, ethernet-cable and battery:

  1. 1.

Insert finger-pair into QFE mechanism

  2. 2.

Regular task-experiments

  3. 3.

Non-regular task-experiments

  4. 4.

Grasp-stability test

  5. 5.

Regular task-experiments with position offsets

  6. 6.

Place finger-pair back to QFE mechanism

First step is the insertion of a finger-pair into the QFE mechanism, in order
to conduct the following task experiments.

The regular task-experiments evaluate the task execution, the fingertips are
actually designed for, with the following main steps (see Fig.9): (1) Pick and
extract the manipulation object from its original storage. (2) Insert the
object into a new target slot. (3) Pick the object again and (4) insert it
back to its original storage slot. In case of the key, an additional key
turning step is conducted after inserting the key into its target-slot - the
lock, to validate full insertion. A task experiment is counted as successful
if all previously mentioned steps have been successfully conducted.

To evaluate the generalization abilities of the designed and automatically
produced fingertips, we conduct the task-experiments with the same finger pair
also for the other manipulation objects (non-regular task-experiment). E.g.,
we execute the task-experiments for the ethernet-cable and battery scenario
with the finger-pair designed for the key object. This should give insights
how universal the different fingertip prototypes can be used.

Further we evaluate the grasp stability by grasping the manipulation object
and pressing it against the inner surface of a ring with 5N pushing force in
two different directions (see Fig. 7). In order to check if the grasped object
is loose and does move during the test, the cartesian position of the robots
endeffector after the pushing execution is compared to the expected position
before the pushing action. The mean square error between both positions is
calculated and compared with a critical limit - indicating if the key moved
significantly ($>$ 5mm).

Finally, the regular task-experiments are conducted with a series of position-
offsets applied for each grasping approach pose777The pose right before the
gripper grasps the manipulation object. For each coordinate axis x, y, z, five
different position offsets 1-5mm and three different rotation offsets 5-15
degree are applied (see Fig. 7). This results in 24 overall offset experiments
which enable the evaluation of the execution robustness of the fingers
regarding potential robot-arm position-errors. Single axis offset experiments
enable a systematic and clear connection analysis between the position error
(direction and absolute value) and the resulting task execution performance.
Contrary, the application of combined offset-errors along multiple axis
applied to the same time, make a clear identification of the performance
influencing parameters difficult if not impossible.

Figure 7: (a) Coordinate axis indicating the used offset translation and
rotation directions. (b) Z position offset visualization for key manipulation
object example. (C1-3) Grasp stability test setup and visualization of applied
pushing directions. The test evaluates if the end-effector moves beyond the
ring-border to check for ineffective object grasping.

Results: For each manipulation object, 28 experiments have been conducted per
trial. Accordingly, ten trials for three different manipulation objects result
in 840 overall experiments. Fig.8 contains the success-rates for those
experiments - conducted by a certain finger-type - where at least one
experiment shows a success-rate smaller then one. The other not shown
experiments showed all a success-rate of one.
It can be concluded that the regular tasks, the lower offset error experiments
and the grasp stability tests could be robustly executed for all manipulation-
objects. On the other hand larger offsets caused different results for the
tested fingers. While all finger-types could handle the z-position offsets
robustly, the medium to large rotation offsets caused unreliable task
execution of nearly all finger-types. Interestingly, the different finger-
types show success-rates of 100% for certain particularly large rotation
offsets. These offsets in combination with the individual geometry seem to
create a new stable grasping configuration, enabling a success-full task-
conduction despite significant offset errors. Beside this general
observations, the different finger-types showed the following individual
characteristics:
Finger A (key object), shows problems regarding the larger y-position,
z-rotation and x-rotation offsets. The remaining position offsets could be
handled with a relatively high success-rate. Finger B (battery object), shows
the highest robustness of all fingers. The biggest problems occured for the
larger y and x rotation offsets. Finger C (ethernet-cable), displays leaking
robustness especially for the y-position as well as the y and x rotation
offsets.
Regarding generalization, finger B (battery object) and finger C performed
best, while finger A (key object) was not able to successfully execute the
tasks for the other objects (battery and ethernet-cable). This can be
explained by the significantly bigger V-chamfer shape of fingertip B compared
to finger A and supports the assumption that V-shaped fingertips increase
grasping-robustness.

Figure 8: Success rates of all task experiments (conducted by the three
different finger-types) which show a success-rate unequal to one for at least
one finger-type. The remaining task experiments not shown here, have a
success-rate of one for all finger-types.

##  IV Discussion and Conclusion

The experimental results show that our approach successfully provides an
improved level of finger production and usage automation. This level of
automation enables a time and cost efficient change of the production setup
for a new assembly task. Accordingly, our approach is a step further to fully
customized one batch size product/system production.

Additionally, the provided 3D printing pipeline potentially reduces the
iteration and adaption time of novel gripper finger designs since multiple
manual steps have been automated and the decoupling of finger-base and finger-
tip production reduces the required printing time significantly, since only
the smaller finger-tip must be printed ad hoc. This decoupling reduces the
design complexity as well, due to the fact that only the fingertip geometry
must be considered and defined.

Additionally, the presented quick-finger-exchange system increases operation
flexibility and performance of robot-arms, since multiple - for a certain
operation specialized fingers - can be exchanged during the task-execution.
The implementation of a finger-exchange system compared to an end-effector
change approach, enables the continues usage of existing and potentially
expensive gripper systems. This simplifies scaling the number of changeable
”tools” from an economical as well as design complexity point of view
significantly. Such an increasing number of ”on the fly” changeable task-
specific fingertips could increase the number of tasks and applications a
single robot can conduct. Additionally, task specialized fingertips
potentially increase manipulation performance and robustness. This enables the
execution of complex tasks, composed by sub-tasks which require specialized
fingertips to be successfully conducted. Accordingly, a robot with a quick-
finger-exchange system can potentially perform a significantly larger number
of tasks better and more robust, then a general multipurpose gripper finger
system.

This improved flexibility and performance could be further enhanced by
advancing the current setup to a fully automatic fingertip identification
pipeline. This pipeline could automatically design, produce and apply
fingertips for a given set of manipulation objects and task scenarios. Such an
approach would reduce required finger development and production setup times
significantly, while decoupling the design quality from the individual skills
and experience of a single designer.

In this context, the presented setup requires many different tactile
manipulation operations, only possible by force/torque sensorized compliant
robot-arms. Accordingly, the described pipeline could potentially build the
foundation for a novel production paradigm: Tactile 3D manufacturing. The
concept of fully automated, adaptive 3D printing based system manufacturing
and iteration could potentially be applied to other application scenarios like
sensor or actuator development as well.

Accordingly, future work will focus on further improving and extending the
current production and task execution setup. The currently used finger-base
version is limited to a certain group of rather small manipulation objects,
which can only be grasped at the outer surface. To manipulate objects with
other form factors, different finger-bases would be required. A next iteration
could integrate such a wider spectrum of different finger-base geometries.
Furthermore, a fully automatic fingertip designer will be developed and
interfaced with the production unit in order to achieve a fully automatic
identification of the fingertips, required for a given manipulation scenario.

Figure 9: Regular Task Experiments conducted via the IoT-Box: (task-A) Pick
key, insert into lock and turn it. (task-B) Pick battery and insert into
battery-holder. (task-C) Pick Ethernet-cable, and insert into corresponding
Ethernet-plug.

##  V Acknowledgements

The authors also would like to thank Robin Kirschner for her fruitful
discussions and contributions.

## References

  * [1] H. Ha, S. Agrawal, and S. Song, “Fit2form: 3d generative model for robot gripper form design,” _arXiv preprint arXiv:2011.06498_ , 2020.
  * [2] R. G. Brown and R. C. Brost, “A 3-d modular gripper design tool,” _IEEE Transactions on Robotics and Automation_ , vol. 15, no. 1, pp. 174–186, 1999.
  * [3] P. Pedrazzoli, R. Rinaldi, and C. Boer, “A rule based approach to the gripper selection issue for the assembly process,” in _Proceedings of the 2001 IEEE International Symposium on Assembly and Task Planning (ISATP2001). Assembly and Disassembly in the Twenty-first Century. (Cat. No.01TH8560)_ , 2001, pp. 202–207.
  * [4] D. T. Pham and E. Tacgin, “An expert system for selection of robot grippers,” _Expert Systems With Applications_ , vol. 5, no. 3-4, pp. 289–300, 1992.
  * [5] D. T. Pham, N. S. Gourashi, and E. E. Eldukhri, “Automated configuration of gripper systems for assembly tasks,” _Proceedings of the Institution of Mechanical Engineers, Part B: Journal of Engineering Manufacture_ , vol. 221, pp. 1643–1649, 2007.
  * [6] R. Saravanan, S. Ramabalan, N. G. R. Ebenezer, and C. Dharmaraja, “Evolutionary multi criteria design optimization of robot grippers,” _Applied Soft Computing Journal_ , vol. 9, no. 1, pp. 159–172, 2009.
  * [7] F. Chen, W. Xu, H. Zhang, Y. Wang, J. Cao, M. Y. Wang, H. Ren, J. Zhu, and Y. Zhang, “Topology optimized design, fabrication, and characterization of a soft cable-driven gripper,” _IEEE Robotics and Automation Letters_ , vol. 3, no. 3, pp. 2463–2470, 2018.
  * [8] C.-H. Liu, T.-L. Chen, T.-Y. Pai, C.-H. Chiu, W.-G. Peng, and M.-C. Hsu, “Topology synthesis, prototype, and test of an industrial robot gripper with 3d printed compliant fingers for handling of fragile objects,” in _2018 WRC Symposium on Advanced Robotics and Automation (WRC SARA)_ , 2018, pp. 189–194.
  * [9] C.-H. Liu, F.-M. Chung, Y. Chen, C.-H. Chiu, and T.-L. Chen, “Optimal design of a motor-driven three-finger soft robotic gripper,” _IEEE/ASME Transactions on Mechatronics_ , vol. 25, no. 4, pp. 1830–1840, 2020.
  * [10] M. Honarpardaz, M. Tarkian, J. Ölvander, and X. Feng, “Finger design automation for industrial robot grippers: A review,” _Robotics and Autonomous Systems_ , vol. 87, pp. 104–119, 1 2017.
  * [11] M. Honarpardaz, M. Meier, and R. Haschke, “Fast grasp tool design: From force to form closure,” in _2017 13th IEEE Conference on Automation Science and Engineering (CASE)_ , 2017, pp. 782–788.
  * [12] M. Honarpardaz, M. Tarkian, J. Ölvander, and X. Feng, “Experimental verification of design automation methods for robotic finger,” _Robotics and Autonomous Systems_ , vol. 94, pp. 89–101, 8 2017.
  * [13] M. Honarpardaz, J. Ölvander, and M. Tarkian, “Fast finger design automation for industrial robots,” _Robotics and Autonomous Systems_ , vol. 113, pp. 120–131, 3 2019.
  * [14] H. Song, M. Y. Wang, and K. Hang, “Fingertip surface optimization for robust grasping on contact primitives,” _IEEE Robotics and Automation Letters_ , vol. 3, pp. 742–749, 4 2018.
  * [15] L. Balan and G. M. Bone, “Automated gripper jaw design and grasp planning for sets of 3d objects,” _Journal of Robotic Systems_ , vol. 20, pp. 147–162, 3 2003.
  * [16] V. Velasco and W. S. Newman, “Computer-assisted gripper and fixture customization using rapid-prototyping technology,” in _Proceedings. 1998 IEEE International Conference on Robotics and Automation (Cat. No. 98CH36146)_ , vol. 4. IEEE, 1998, pp. 3658–3664.
  * [17] B. S. Homberg, R. K. Katzschmann, M. R. Dogar, and D. Rus, “Haptic identification of objects using a modular soft robotic gripper,” _2015 IEEE/RSJ international conference on intelligent robots and systems (IROS)_ , vol. 4, pp. 1698–1705, 2015.
  * [18] P. J. Leitão _et al._ , “Development and simulation of an automatic tool changer for an abb robot,” _Master’s degree dissertation_ , 2019.
  * [19] B.-S. Ryuh, S. M. Park, and G. R. Pennock, “An automatic tool changer and integrated software for a robotic die polishing station,” _Mechanism and Machine Theory_ , vol. 41, no. 4, pp. 415–432, 2006.
  * [20] C. Clévy, A. Hubert, J. Agnus, and N. Chaillet, “A micromanipulation cell including a tool changer,” _Journal of Micromechanics and Microengineering_ , vol. 15, no. 10, p. S292, 2005.
  * [21] T. Chagouri, F. Al-Darwish, A. Sharif, and Y. Al-Hamidi, “Product design journey: Novel tool changer,” in _ASME International Mechanical Engineering Congress and Exposition_ , vol. 85659. American Society of Mechanical Engineers, 2021, p. V009T09A025.
  * [22] H. Ambrosio and M. Karamanoglu, “Design and development of an automatic tool changer for an articulated robot arm,” in _IOP Conference Series: Materials Science and Engineering_ , vol. 65, no. 1. IOP Publishing, 2014, p. 012023.
  * [23] K. Brillowski, “Sturdy tool changer,” _Industrial Robot: An International Journal_ , 1996.
  * [24] P. Dhakal, “Design of automatic tool changer for universal collaborative robot,” _Bachelor’s thesis_ , 2019.
  * [25] M. Babcinschi, “Automatic tool changer on collaborative robots,” Ph.D. dissertation, Universidade de Coimbra, 2018.
  * [26] A. Pettinger, C. Dimoush, and M. W. Pryor, “Passive tool changer development for an elastic and compliant manipulator,” _2019 IEEE 15th International Conference on Automation Science and Engineering (CASE)_ , pp. 1200–1205, 2019.
  * [27] R. Berenstein, A. Wallach, P. E. Moudio, P. Cuellar, and K. Goldberg, “An open-access passive modular tool changing system for mobile manipulation robots,” in _2018 IEEE 14th International Conference on Automation Science and Engineering (CASE)_. IEEE, 2018, pp. 592–598.
  * [28] D. Gyimothy and A. Toth, “Experimental evaluation of a novel automatic service robot tool changer,” _2011 IEEE/ASME International Conference on Advanced Intelligent Mechatronics (AIM)_ , pp. 1046–1051, 2011.
  * [29] D. C. Friedman, J. Dosher, T. Kowalewski, J. Rosen, and B. Hannaford, “Automated tool handling for the trauma pod surgical robot,” in _Proceedings 2007 IEEE International Conference on Robotics and Automation_. IEEE, 2007, pp. 1936–1941.
  * [30] S. McKinley, A. Garg, S. Sen, D. V. Gealy, J. P. McKinley, Y. Jen, M. Guo, D. Boyd, and K. Goldberg, “An interchangeable surgical instrument system with application to supervised automation of multilateral tumor resection,” in _2016 IEEE International Conference on Automation Science and Engineering (CASE)_. IEEE, 2016, pp. 821–826.
  * [31] S. B. Backus and A. M. Dollar, “An adaptive three-fingered prismatic gripper with passive rotational joints,” _IEEE Robotics and Automation Letters_ , vol. 1, no. 2, pp. 668–675, 2016.
  * [32] Z. Ren, N. Kashiri, C. Zhou, and N. G. Tsagarakis, “Heri ii: A robust and flexible robotic hand based on modular finger design and under actuation principles,” in _2018 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS)_. IEEE, 2018, pp. 1449–1455.
  * [33] G. Causey, “Guidelines for the design of robotic gripping systems,” _Assembly automation_ , 2003.
  * [34] T. Bajd, M. Mihelj, and M. Munih, _Introduction to robotics_. Springer Science & Business Media, 2013.
  * [35] O. P. D. printers directly from Josef Prusa, “www.prusa3d.com,” _online_ , 2009.
  * [36] J. M. Miro Hrončok, Jiří Makarius, “Octorest.” [Online]. Available: https://github.com/dougbrion/OctoRest
  * [37] G. Häußge, “Octoprint.” [Online]. Available: https://octoprint.org/
  * [38] L. Johannsmeier, M. Gerchow, and S. Haddadin, “A framework for robot manipulation: Skill formalism, meta learning and adaptive control,” in _2019 International Conference on Robotics and Automation (ICRA)_. IEEE, 2019, pp. 5844–5850.
  * [39] F. Voigt, L. Johannsmeier, and S. Haddadin, “Multi-level structure vs. end-to-end-learning in high-performance tactile robotic manipulation,” in _Proceedings of the 2020 Conference on Robot Learning_ , vol. 155. PMLR, 16–18 Nov 2021, pp. 2306–2316.
  * [40] P. So, J. Wittmann, P. Ruhkamp, A. Sarabakha, and S. Haddadin, “Towards remote robotic competitions: An internet-connected task board and dashboard,” _arXiv preprint arXiv:2201.09565_ , 2022.