Graph Theory and Algorithms

2025-03-13T20:37:17Z

SAFFER Zsolt:

= Graph Theory and Algorithms =

For a comprehensive subject on graph theory the reader is referred to the book [Gross and Yellen(1998)].


== Seven Bridges of Königsberg ==

Seven Bridges of Königsberg is a problem of mathematics formulated by Leonhard Euler after a walk in Königsberg in Prussia (now Kaliningrad, Russia). The islands were connected to each other and the mainlands on the two sides of the Pregel River via seven bridges (see Figure [[#fig:Königsberg_bridges|2]]).

<div id="fig:Königsberg_bridges" class="figure">

[[Datei:Konigsberg_bridges_2L.png|460px|thumb|center|Figure 2: Map of Königsberg with the seven bridges in the 18-th century (Source: By Bogdan Giuşcă - Public domain (PD),based on the image, CC BY-SA 3.0, \url{https://commons.wikimedia.org/w/index.php?curid=112920})]]

</div>
The problem is to find a walk path that would cross each of the seven bridges only once.

Leonhard Euler has resolved the problem in 1736 by showing that such a walk path does not exist. His solution founded the graph theory and therefore the Seven Bridges of Königsberg problem is considered to be the first problem of graph theory.


== Graphs theory basics ==

A graph is a mathematical object consisting of vertices (nodes) and edges connecting pairs of vertices, see example in Figure [[#fig:exa_undirected_graph|3]].

<div id="fig:exa_undirected_graph" class="figure">

[[Datei:exa_undirected_graph.jpg|460px|thumb|center|Figure 3: Example of an undirected graph]]

</div>
Graph theory studies properties of graphs and problems which can be described by means of graphs. Graph theoretical algorithms and results are applied in many areas, like e.g. transport networks, computer science or biology.


=== Basics ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Basic terms'''

A graph is composed of vertices (nodes) and edges connecting pairs of vertices. Vertex and edge are the two basic units of the graph. The set of vertices and edges is denoted by <math display="inline">\mathcal{V}</math> and <math display="inline">\mathcal{E}</math>, respectively. In undirected graph the edges have no direction, they simple connect two vertices. The graph shown in Figure [[#fig:exa_undirected_graph|3]] is an example of an undirected graph.

The degree of a vertex is the number of edges connected to it. A path is an uninterrupted line connecting two vertices over sequence of edges and vertices. For example the path <math display="inline">(1,2,5,6)</math> in Figure [[#fig:exa_undirected_graph|3]] connects the vertices <math display="inline">1</math> and <math display="inline">6</math>. This way a path is specified by an ordered list of all vertices locating on the uninterrupted line going from the starting vertex of the path to the end vertex of it. A cycle is a path, whose start vertex and end vertex is the same. For example <math display="inline">(1,2,3,4,1)</math> in Figure [[#fig:exa_undirected_graph|3]] is a cycle. A graph is called connected graph, if there is a path between any two vertices of the graph. For example the graph in Figure [[#fig:exa_undirected_graph|3]] is a connected graph.

In the weighted graph each edge has a weight (or cost) associated to them. This weight can represent different physical properties, like e.g. distance between two nodes, capacity of a network link, transport cost of a way between two nodes, etc. An example of a weighted graph can be seen in Figure [[#fig:exa_weighted_graph|4]].

<div id="fig:exa_weighted_graph" class="figure">

[[Datei:exa_weighted_graph.jpg|460px|thumb|center|Figure 4: Example of a weighted graph]]

</div>
'''<math display="inline">\mathrm{\ \ \ \ }</math> Types of graphs'''

The classification of graphs into various types is based on the properties of the considered subclass of graphs. The most important types of graphs together with their definitions are given as follows.

* Undirected graph - A graph with edges having no direction.
* Directed graph - A graph with edges having direction.
* Unweighted graph - A graph with edges having no weights associated to them.
* Weighted graph - A graph with edges having weights associated to them.
* Connected graph - A graph having path between any two of its vertices.
* Disconnected graph - A graph containing at least one pair of vertices having no path between them.
* Cyclic graph - A graph containing at least one cycle.
* Acyclic graph - A graph does not containing any cycles.
* Tree - A connected acyclic graph.
* Multi-graph - A graph containing at least one pair of vertices having multiple edges between them.
* Simple graph - A graph without cycles and multiple edges between the same pair of vertices.
* Complete graph - A graph in which each pair of vertices is connected by edge.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Graph descriptions'''

The most often used graph representations in algorithms are

* adjacency matrix and
* adjacency list,

because they enable the mathematical description of graphs by means of programming variables, like matrix, array and list.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Adjacency matrix'''''

Adjacency matrix is suitable to describe unweighted graphs, both undirected and directed ones. Adjacency matrix is a <math display="inline">V \times V</math> matrix, whose <math display="inline">(i,j)</math>-th element describes the existence of the connection from vertex <math display="inline">i</math> to vertex <math display="inline">j</math> as a binary value. If there is a connection then this value equals <math display="inline">1</math>, otherwise <math display="inline">0</math>. For example the adjacency matrix of the undirected, unweighted graph example in Figure [[#fig:exa_undirected_graph|3]] looks like

<math display="block">\begin{aligned}
\left(
\begin{array}{llllll}
0 & 1 & 0 & 1 & 0 & 0\\
1 & 0 & 1 & 0 & 1 & 0\\
0 & 1 & 0 & 1 & 0 & 0\\
1 & 0 & 1 & 0 & 1 & 0\\
0 & 1 & 0 & 1 & 0 & 1\\
0 & 0 & 0 & 0 & 1 & 0
\end{array}
\right).
\end{aligned}</math>

The construction of the adjacency matrix implies that the adjacency matrix of an undirected graph is always a symmetric matrix. The idea of describing an unweighted graph by constructing an adjacency matrix as 2-dimensional array can be theoretically extended to describe a weighted graph by constructing a 3-dimensional array, in which the third dimension represents the weight assigned to the edge specified by the first two dimensions. Such a 3-dimensional could be called as adjacency tensor.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Adjacency list'''''

Another way of mathematical representation of a graph is the adjacency list. Adjacency list is an array of lists, in which each list specifies a set of neighbours of a vertex assigned to the actual list as index of the array. In describing a weighted graph, the list consists of the comma separated sequence of "ending vertex: weight" pairs, where each such pair specifies an edge to the given ending vertex with the given weight starting from the vertex to which the considered list belongs to. In case of an unweighted graph the list is a comma separated sequence of neighbour vertexes of the vertex to which the considered list belongs to. Therefore this type of representation is suitable to describe both unweighted and weighted graphs. For example the adjacency list of the unweighted graph example in Figure [[#fig:exa_undirected_graph|3]] is given as

<math display="block">\begin{aligned}
\begin{array}{ll}
1: & \{2,4\} \\
2: & \{1,3,5\}\\
3: & \{2,4\} \\
4: & \{1,3,5\} \\
5: & \{2,4,6\} \\
6: & \{5\}
\end{array}.
\end{aligned}</math>

Similarly the adjacency list of the weighted graph example in Figure [[#fig:exa_weighted_graph|4]] can be given as

<math display="block">\begin{aligned}
\begin{array}{ll}
1: & \{2:5,3:2\} \\
2: & \{1:5,3:3,4:4\}\\
3: & \{1:2,2:3,4:1\} \\
4: & \{2:4,3:1,5:3\} \\
5: & \{1:8,4:3\}
\end{array}.
\end{aligned}</math>

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Edge list'''''

Still another way of mathematically describing a graph is to specify it as edge list. Each edge is specified by a sequence in the form <math display="inline">[</math> starting vertex, ending vertex, weight (optional) <math display="inline">]</math>. Thus the edge list can be given as a two/three column matrix for unweighted/weighted graphs. Hence this type of representation is suitable to describe both unweighted and weighted graphs. The unweighted graph in Figure [[#fig:exa_undirected_graph|3]] and the weighted graph in Figure [[#fig:exa_weighted_graph|4]] can be described by edge list, respectively, as

<math display="block">\begin{aligned}
&&[ [1,2], [2,3], [1,4], [4,5], [2,5], [3,4], [5,6] ] \\
&&[ [1,2,5], [2,3,3], [3,1,2], [2,4,4], [4,3,1], [1,5,8], [4,5,3] ].
\end{aligned}</math>


=== Graph problems ===

Graph theory can be applied for solving different problems in many areas. Without claim for completeness we list several well-known graph problems with their brief description.

* Graph coloring - Graph coloring is a group of problems all of them having something to do with coloring of graphs. Usually they are specified by means of a restriction on the way of coloring, like e.g no adjacent vertices may have the same color. One of the famous result in graph coloring is the so called [https://en.wikipedia.org/wiki/Four_color_theorem Four-color theorem]
* Network flow problems - Network flow problems deal with question related to [https://en.wikipedia.org/wiki/Flow_network Flow networks].
* Covering problems - Covering problems are set cover problems dealing with covering some subsets of vertices/subgraphs. Vertex cover problem is a special case of set cover problems, in which for every edge its starting or end vertex is in the vertex cover.
* Route problems - Route problems are graph problems, which are all related to find a route specified by various constraints on the graph.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Route problems''' 
Route problems form an important class of graph problems, since they have applications in many areas. Here is a list of several selected Route problems, which will be discussed in more details in the rest of this section.

# Hamiltonian path and Eulerian path
# Traveling salesman problem
# Chinese postman problem (Route inspection problem)
# Minimum spanning tree
# Shortest path problem


== Minimum Vertex Cover Problem ==

Vertex cover problem is a kind of set cover problems, in which a set of vertices are searched, which includes at least one endpoint of every edge of the graph. The Minimum Vertex Cover Problem (MIN-VC) is a vertex cover problem on undirected graph, in which a set of minimum number of vertices are searched, which includes at least one endpoint of every edge of the graph.

<div id="fig:exa_graph_minvc" class="figure">

[[Datei:exa_graph_minvc.jpg|460px|thumb|center|Figure 5: Example graph for MIN-VC problem]]

</div>
For example the minimum vertex cover of the example graph in Figure [[#fig:exa_graph_minvc|5]] is <math display="inline">\{2,3,4\}</math> or <math display="inline">\{2,3,5\}</math> or <math display="inline">\{2,4,5\}</math> or <math display="inline">\{1,3,5\}</math>.

The MIN-VC is an optimization problem and it can be reformulated to a decision problem, which is also called as "vertex cover problem". It is known to be [https://en.wikipedia.org/wiki/NP-completeness NP-complete] (nondeterministic polynomial-time complete), so usually so it cannot be solved by a polynomial-time algorithm.

There is an approximate algorithm for determining the minimum vertex cover of an undirected graph. Its schematic representation is shown in Algorithm 1.

 
Algorithm 1 Approximate algorithm for MIN-VC 
'''—————————————————————————————''' 
Input: Undirected graph given by an edge list (= set <math display="inline">\mathcal{E}</math>). 
Output : Found set of vertex cover <math display="inline">\mathcal{C}</math>. 
'''—————————————————————————————''' 
1 Initialise set of vertex cover: <math display="inline">\mathcal{C}</math>=<math display="inline">\{\}</math> 
2 while <math display="inline">\mathcal{E}</math> is not empty 
3 Take an arbitrary edge <math display="inline">(u,v)</math> from set <math display="inline">\mathcal{E}</math> 
4 Add <math display="inline">u</math> and <math display="inline">v</math> to <math display="inline">\mathcal{C}</math> 
5 Remove all edges from set <math display="inline">\mathcal{E}</math> having endpoint either <math display="inline">u</math> or <math display="inline">v</math> 
6 end 
'''—————————————————————————————''' 

It can be proven that the above approximate algorithm for MIN-VC always finds a vertex cover whose size is not more than twice of the size of the minimum vertex cover. The computational complexity of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|+|\mathcal{E}|)</math>. The memory need of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|</math> The memory is needed to store the visited vertices, i.e. the set <math display="inline">\mathcal{C}</math>.


== Eulerian path and Hamiltonian path ==


=== Eulerian path and cycle ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Eulerian path'''

Eulerian path in an undirected graph <math display="inline">\boldsymbol{G}</math> is a path that visits every edges of <math display="inline">\boldsymbol{G}</math> exactly once. Note that the undirected graph <math display="inline">\boldsymbol{G}</math> can be unweighted or weighted. However this does not affect the mathematical treatment of Eulerian path, therefore we treat these cases commonly by simple omitting unweighted or weighted characterization of <math display="inline">\boldsymbol{G}</math>.

The necessary and sufficient conditions for for the existence of Eulerian path in the undirected graph <math display="inline">\boldsymbol{G}</math> can be given as

* Every vertices with non-zero degree of <math display="inline">\boldsymbol{G}</math> form a connected graph.
* Either none of the vertices or exactly two vertices of <math display="inline">\boldsymbol{G}</math> have odd degree and all its other vertices have even degree.

Along the Euler path, each time walking through a vertex we walking through two previously unseen edges: one at approaching the vertex and the other at leaving it. On this way the number of edges at each middle vertex (i.e. the vertices except the starting and ending vertices of the path) must be even. The starting and ending vertices of the path are enabled to have odd degree, as the start or finish of the walk goes through on only one edge connected to that vertices. This argument proves the necessity of the condition. It turns out that the condition is also sufficient.

<div id="fig:exa_graph_E-path" class="figure">

[[Datei:exa_graph_E-path.jpg|460px|thumb|center|Figure 6: Example graph with Euler path]]

</div>
For example the example graph in Figure [[#fig:exa_graph_E-path|6]] has an Euler path <math display="inline">(1,3,4,5,2,4)</math>, since only vertices <math display="inline">1</math> and <math display="inline">4</math> have odd degree.

An Euler path can be determined by going through the graph starting from a vertex with odd degree and selecting always previously unseen edges at each vertices. The conditions ensure that this always leads to an Euler path. This process requires the logging of the already visited edges at each vertex. It follows that the computational complexity of finding an Euler path is <math display="inline">\mathcal{O}(|\mathcal{V}|^2</math>

The Seven Bridges of Königsberg is a problem of finding an Euler path. In fact Leonard Euler solved it in 1736 by showing that there is no path that visits every of the seven bridges exactly once. His solution applies the above argument for necessary condition. Euler’s solution of the Königsberg bridge problem is the first theorem of graph theory and laid the foundations of graph theory.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Eulerian cycle'''

Eulerian cycle in an undirected graph <math display="inline">\boldsymbol{G}</math> is a closed path that visits every edges of <math display="inline">\boldsymbol{G}</math> exactly once and returns to the starting vertex. Similarly to Eulerian path, the undirected graph <math display="inline">\boldsymbol{G}</math> can be unweighted or weighted, which does not affect of the mathematical treatment of Eulerian cycle. Hence these cases are treated commonly by simple omitting unweighted or weighted characterization of <math display="inline">\boldsymbol{G}</math>. A graph containing a Eulerian cycle is a Eulerian graph.

The necessary and sufficient conditions for the existence of Eulerian cycle in the undirected graph <math display="inline">\boldsymbol{G}</math> can be formulated as

* Every vertices with non-zero degree of <math display="inline">\boldsymbol{G}</math> form a connected graph.
* Every vertices of <math display="inline">\boldsymbol{G}</math> have even degree.

This can be argumented similarly as in case of Eulerian path. Because in case of Eulerian cycle the path returns to the starting vertex, no odd degree is allowed yet for that vertex.

The example graph in Figure [[#fig:exa_graph_E-path|6]] has no Eulerian cycle, since not every vertices have even degree (vertices <math display="inline">1</math> and <math display="inline">4</math> have odd degree).

<div id="fig:exa_graph_E-cycle" class="figure">

[[Datei:exa_graph_E-cycle.jpg|460px|thumb|center|Figure 7: Example graph with Eulerian cycle]]

</div>
However the in the graph in Figure [[#fig:exa_graph_E-cycle|7]] every vertices have even degree, therefore it has a Eulerian cycle, e.g. (1,3,5,6,7,5,4,3,2,1).

Finding a Eulerian cycle can be completed on the same way as described for Eulerian path, but the visit can start at any vertex, since all vertices have even degree. Like in case of finding an Eulerian path, finding a Eulerian cycle has a computational complexity of <math display="inline">\mathcal{O}(|\mathcal{V}|^2</math>.


=== Hamiltonian path and cycle ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Hamiltonian path'''

Hamiltonian path in an undirected graph <math display="inline">\boldsymbol{G}</math> is a path that goes through every vertex of <math display="inline">\boldsymbol{G}</math> exactly once. The path have not to return to the starting vertex, i.e. Hamiltonian path is an open path. Finding a Hamiltonian path is in general an NP-complete problem.

For example the example graph in Figure [[#fig:exa_undirected_graph|3]] has more Hamiltonian paths: <math display="inline">(3,2,1,4,5,6)</math> or <math display="inline">(1,4,3,2,5,6)</math>.

Hamiltonian path has applications in many fields including

* transportation networks (finding optimal routes),
* circuit design and
* graph theory research.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Hamiltonian cycle'''

Hamiltonian cycle (or Hamiltonian circuit) in an undirected graph <math display="inline">\boldsymbol{G}</math> is a closed path that goes through every vertex of <math display="inline">\boldsymbol{G}</math> exactly once and returns to the starting vertex. A graph containing a Hamiltonian cycle is a Hamiltonian graph, otherwise it is non-Hamiltonian graph. Like in case of finding a Hamiltonian path, finding a Hamiltonian cycle is also an NP-complete problem. Finding a Hamiltonian path is often easier than finding a Hamiltonian cycle.

The example graph in Figure [[#fig:exa_undirected_graph|3]] has no Hamiltonian cycle.

<div id="fig:exa_graph_H_cycle" class="figure">

[[Datei:exa_graph_H_cycle.jpg|460px|thumb|center|Figure 8: Example graph with Hamiltonian cycle]]

</div>
However a slightly different graph in Figure [[#fig:exa_graph_H_cycle|8]] has a Hamiltonian cycle: (5,2,1,4,3,5).

Hamiltonian cycle has applications in many fields including

* computer science,
* logistics and
* network design.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Algorithms for finding Hamiltonian cycle'''

In the next we give a brief description of the following two algorithms for finding Hamiltonian cycle:

* Brute-force search and
* Backtracing algorithm

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Brute-force search - for finding Hamiltonian cycle'''''

The brute-force search (also called exhaustive search) follows a naive approach and tries all the possible permutations of all the <math display="inline">|V|</math> vertices. This results in <math display="inline">|V|!</math> different sequences of the <math display="inline">|V|</math> vertices, so the computational complexity of this algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|!)</math>.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Backtracing algorithm - for finding Hamiltonian cycle'''''

The idea of Backtracing algorithm is to add iteratively a new vertex to the actual path of subsequence of vertices, which is an adjacent to the last vertex of the actual path and not yet included in that path. After having the path with <math display="inline">|\mathcal{V}|</math> vertices, it is checked whether it composes a cycle or not. If not then change the path by trying systematically all the adjacent vertices at every position in the path backwards, which is called backtracking.

The algorithm can be implemented on elegant way by applying a recursive function call. The pseudo code of the algorithm is given in Algorithm 2.

 
Algorithm 2 Backtracing algorithm - for finding Hamiltonian cycle 
'''—————————————————————————————''' 
Input: Undirected graph. 
Output: 
- true, if Hamiltonian cycle found, 
- false, if Hamiltonian cycle exist 
'''—————————————————————————————''' 
1 Initialise path (=sequence of <math display="inline">|\mathcal{V}|</math> vertices) 
2 Set <math display="inline">path[0]</math>= first vertex 
3 if <math display="inline">try\_next\_vertex\_and\_check\_cycle(1)</math> 
4 return <math display="inline">true</math> (cycle found) 
5 else 
6 return <math display="inline">false</math> (cycle not exists) 
7 end 
'''—————————————————————————————''' 
Recursive function 
bool try_next_vertex_and_check_cycle(path_index k) 
Input: next index in the path (=sequence of <math display="inline">|\mathcal{V}|</math> vertices) 
Output: 
- true, if cycle found, 
- false, if backtracking or cycle not exists 
'''—————————————————————————————''' 
1 if <math display="inline">k == |\mathcal{V}|</math> 
2 if exists edge between last and first vertices of path 
3 return <math display="inline">true</math> (cycle found) 
4 else 
5 return <math display="inline">false</math> (backtracking or cycle not exists) 
6 end 
7 for <math display="inline">v \in \mathcal{V}</math> 
8 if <math display="inline">v</math> is adjacent to <math display="inline">path[k-1]</math> (=last vertex in path) 
9 and 
10 <math display="inline">v</math> is not yet in <math display="inline">path[]</math> 
11 path[k]=v 
12 if <math display="inline">try\_next\_vertex\_and\_check\_cycle(k+1)</math> 
13 return <math display="inline">true</math> 
14 end 
15 (Backtracking - remove v from path) 
16 <math display="inline">path[k] = -1</math> 
17 end 
18 end 
19 return false (backtracking or cycle not exists) 
'''—————————————————————————————''' 

In the course of backtracking every neighbours of every vertices can be tried by the algorithm. Therefore its computational complexity is <math display="inline">\mathcal{O}(|\mathcal{V}|!)</math>.


== Chinese postman problem (Route inspection problem) ==

The Chinese postman problem (also called as route inspection problem) is an extension of finding Eulerian cycle in connected and (unweighted or weighted) undirected graphs. The Chinese postman problem is to find shortest path that visits every edge of the connected and undirected graph <math display="inline">\boldsymbol{G}</math> at least once and return to the starting vertex. So the problem is defined on connected graph. The shortest path is defined as the one with minimum number of edges for unweighted graph and as the path with minimum accumulated weights for weighted graph. The solution path of Chinese postman problem is called Chinese postman tour. The Chinese postman problem can be solved in polynomial time.


=== Solution for Eulerian graph ===

If the graph <math display="inline">\boldsymbol{G}</math> contains an Eulerian cycle, then it is also the solution for the Chinese postman problem, since Eulerian cycle has the shortest path (minimum number of edges in unweighted graph and minimum accumulated weights in weighted graph) due to the necessity of visiting all edges at least once.

Therefore the necessary and sufficient condition for the solution for the Chinese postman problem to be the Eulerian cycle is the existence of Eulerian cycle, which can be given as

* Every vertices of <math display="inline">\boldsymbol{G}</math> have even degree.

For example graph in Figure [[#fig:exa_graph_E-cycle|7]] the solution, i.e the Chinese postman tour is the Eulerian cycle, e.g. (1,3,5,6,7,5,4,3,2,1).


=== Solution for Non-Eulerian graph ===

If the graph <math display="inline">\boldsymbol{G}</math> has no Eulerian cycle, then the graph must be extended to become Eulerian. This is done by duplicating some edges of <math display="inline">\boldsymbol{G}</math> connected to vertices with odd degree in order to change the degree of all these vertices become to even. The edges to be duplicated must be selected from the relevant ones (i.e. connected to vertices with odd degree) on that way, that the increase of the path length due to edge duplication must be the possible smallest. Therefore those pairing of the vertices with odd degree are selected, which have the shortest path connecting them.

The example unweighted graph in Figure [[#fig:exa_graph_cpp_unweighted|9]] shows a Non-Eulerian graph and the Chinese postman tour obtained by duplicating the edges [2,4] and [3,1].

<div id="fig:exa_graph_cpp_unweighted" class="figure">

[[Datei:exa_graph_cpp_unweighted.jpg|460px|thumb|center|Figure 9: Example Non-Eulerian unweighted graph with Chinese postman tour]]

</div>
Similarly the example Non-Eulerian weighted graph in Figure [[#fig:exa_graph_cpp_weighted|10]] illustrates the construction of the Chinese postman by duplicating the edges [2,4], [4,6] and [5,1]. Here duplicating [2,4] together with [4,6] instead of [2,6] inserts shorter path (i.e. accumulated weight 2+1= 3 instead of 5). Similarly duplicating [5,1] instead of [5,3] together with [3,1] inserts shorter path (i.e. accumulated weight 1 instead of 1+2=3).

<div id="fig:exa_graph_cpp_weighted" class="figure">

[[Datei:exa_graph_cpp_weighted.jpg|460px|thumb|center|Figure 10: Example Non-Eulerian weighted graph with Chinese postman tour]]

</div>

=== Algorithm for Chinese postman problem ===

Based on the above considerations the algorithm for finding the Chinese postman route can be given schematically by means of its steps in Algorithm 3.

 
Algorithm 3 Algorithm for Chinese postman problem 
'''—————————————————————————————''' 
Input: Undirected graph <math display="inline">\boldsymbol{G}</math>. 
Output: Chinese postman route. 
'''—————————————————————————————''' 
1 if grap <math display="inline">\boldsymbol{G}</math> is Eulerian 
2 Find an Eulerian cycle in <math display="inline">\boldsymbol{G}</math> 
3 <math display="inline">totalWeight</math> = sum of all edge weights of <math display="inline">\boldsymbol{G}</math> 
4 return Eulerian cycle and <math display="inline">totalWeight</math> 
5 else 
6 Determine <math display="inline">N</math> from graph, <math display="inline">N =|\mathcal{V}|</math> 
7 Find all vertices with odd degree and store in array <math display="inline">oddVertices</math> 
8 Construct the complete graph <math display="inline">\boldsymbol{C}</math> from odd vertices together with edges 
<math display="inline">\mathrm{\ \ \ \ \ }</math>representing shortest paths among any pairs of odd vertices 
9 Find minimum weight perfect matching in <math display="inline">\boldsymbol{C}</math>, i.e the set of edges 
<math display="inline">\mathrm{\ \ \ \ \ }</math> reaching every odd vertices and together having smallest sum of weights. 
<math display="inline">\mathrm{\ \ \ \ \ }</math> This set of edges is called minimum T-join. 
10 Extend the graph <math display="inline">\boldsymbol{G}</math> by adding all edges from minimum T-join 
<math display="inline">\mathrm{\ \ \ \ \ }</math> resulting in extended graph <math display="inline">\boldsymbol{H}</math> 
12 Find an Eulerian cycle in <math display="inline">\boldsymbol{H}</math> 
13 <math display="inline">totalWeight</math> = sum of all edge weights of <math display="inline">\boldsymbol{H}</math> 
14 return Eulerian cycle of <math display="inline">\boldsymbol{H}</math> and <math display="inline">totalWeight</math> 
15 end 
'''—————————————————————————————''' 

The numerical complexity of the above minimum T-join based algorithm for solving the Chinese postman problem is <math display="inline">\mathcal{O}(|\mathcal{V}|^3)</math>, since both setting up the complete graph, and finding minimum weight perfect matching in it takes <math display="inline">\mathcal{O}(|\mathcal{V}|^3)</math> computational steps.


== Minimum spanning tree - Kruskal’s algorithm ==

A spanning tree of a graph is a tree including every vertices of the graph. The number of edges of a spanning tree is <math display="inline">|\mathcal{V}|-1</math>, since the <math display="inline">|\mathcal{V}|</math>-th edge would introduce a cycle and it were not any more a tree.

The minimum spanning tree (MST) is defined for a weighted, undirected, connected graph <math display="inline">\boldsymbol{G}</math>, as a spanning tree with the minimal accumulated weights.

Kruskal’s algorithm can be used to determine the MST of graph <math display="inline">\boldsymbol{G}</math>. In the Kruskal’s algorithm all edges of <math display="inline">\boldsymbol{G}</math> are sorted according to their weights in increasing order. Then the algorithm iteratively adds the next edge from the sorted list, i.e. the edge with the smallest weight, together with their vertexes to MST, if the newly added edge does not induce a cycle. The algorithm proceeds until every edge on the list is checked. On this way the resulted graph will have <math display="inline">|\mathcal{V}|-1</math> edge, so it will be a spanning tree and the way of constructing implies that it will have the least accumulated weights.

The algorithm takes in each step the locally optimal decision due to adding the edge with the smallest weight among the still available ones. Therefore Kruskal’s algorithm is a greedy algorithm.

The algorithm is shown schematically in Algorithm 4.

 
Algorithm 4 Kruskal’s algorithm for detrmining MST 
'''—————————————————————————————''' 
Input: Undirected weighted connected graph <math display="inline">\boldsymbol{G}</math>. 
Output: MST of <math display="inline">\boldsymbol{G}</math>. 
'''—————————————————————————————''' 
1 Initialise graph MST to be set empty. 
2 Sort every edges of <math display="inline">\boldsymbol{G}</math> in increasing weight order and insert them, 
<math display="inline">\mathrm{\ \ }</math> together with their vertexes into array <math display="inline">sortedListEdges[]</math> 
3 for <math display="inline">v=0,\ldots size(sortedListEdges)-1</math> 
4 if inserting <math display="inline">sortedListEdges[v]</math> into MST does not induce a cycle 
5 Add <math display="inline">sortedListEdges[v]</math> into MST 
6 end 
7 end 
8 return MST 
'''—————————————————————————————''' 

The computational complexity of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{E}|))</math>, since sorting the edges has <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{E}|))</math> complexity, iterating through every edges and checking cycle has <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{V}|))</math> and <math display="inline">\mathcal{O}(log(|\mathcal{V}|) =\mathcal{O}(log(|\mathcal{E}|)</math> due to <math display="inline">|\mathcal{E}|</math> is at most <math display="inline">|\mathcal{V}|^2</math>.

The memory need of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|+|\mathcal{E}|)</math>, which is needed to store edges together with their vertexes.


== Traveling salesman problem ==

The Traveling Salesman Problem (TSP) originates from a context of cities and given distances among them. TSP is to look for the shortest path that goes through each city exactly once and returns to the starting city. Usually there exists a route between any pair of cities with some given distance. In graph theory context an equivalent formulation of TSP can be given as looking for a path with the least accumulated weights in a weighted, often complete graph, that goes through each vertex exactly once and returns to the starting vertex. This is equivalent with finding the Hamiltonian cycle with the minimum accumulated weight in a weighted, often complete graph. Thus the TSP is more general than Hamilton cycle problem and hence Hamilton cycle problem is a special case of TSP. The resulted path can be also called as TSP path.

The TSP was formulated mathematically in the 19th century and was first studied mathematically in the 1930s. The decision problem version of TSP is an NP-complete problem, so TSP is NP-hard. TSP is one of the most intensively investigated problem in combinatorial optimization, since it is used as benchmark for other optimization methods in terms of computational complexity.

Some properties of TSP can be provided as

* Symmetric and asymmetric TSP. In symmetric TSP the distance between two cities is the same in both direction, which leads to a formulation in graph theory context to a TSP on undirected graph. In asymmetric TSP either do not exist a path between two cities in both direction or the distances are different excluding the higher one from the TSP formulation. In these cases the formulation in graph theory context yileds a TSP on directed graph.
* Completing the graph by adding edges with sufficiently long distances will not affect the optimal path.
* The path to be a cycle or an open path does not make difference in the computational complexity of TSP (like in case of Hamilton path problem).

The TSP has applications in numerous fields, like logistics, route planning in transport networks, manufacturing of microchips and DNA sequencing. One-way streets, airfares with different departure and arrival fees are real-world scenarios for applying asymmetric TSP.


=== Generalizations of TSP ===

Several generalizations of TSP are listed below.

* The travelling politician problem (also called as "generalized travelling salesman problem") has a context with states having one or more cities and the travelling man must visit exactly one city from each state. It has been shown that travelling politician problem can be led back to standard TSP with modified distance matrix.
* The travelling purchaser problem has a purchaser, who has to buy a set of products, which can be bought in more cities but at different prices. The optimization objective is to find a path among a subset of cities that enables to buy all the products with minimal total cost (=taveling cost + purchasing cost).
* Vehicle routing problem.
* Ring star problem ([Labbé et al.(2004)]).


=== Integer linear programming formulation ===

In order to form the TSP as Integer Linear Programming (ILP) optimization, several variables must be introduced. Let <math display="inline">N</math> denote the number of cities (vertices), i.e. <math display="inline">N = |\mathcal{V}|</math>. Let <math display="inline">c_{ij}</math> stand for the distances (weights) between the cities (vertices) <math display="inline">i</math> and <math display="inline">j</math>, for <math display="inline">i,j = 1, \ldots, N</math>. Let <math display="inline">x_{ij}</math> be a decision variable describing whether the path goes from city (vertix) <math display="inline">i</math> to <math display="inline">j</math>, or not for <math display="inline">i,j = 1, \ldots, N</math>. In other words <math display="block">x_{ij} = \left\{
\begin{aligned}
1, \mathrm{\ \ } \mathrm{~if~path~goes~i \rightarrow j} \\
0, \mathrm{\ \ } \mathrm{~otherwise~~~~~~~~~~~}
\end{aligned}
\right\}.</math> The integer nature of the values <math display="inline">0</math> and <math display="inline">1</math> makes this optimization problem an ILP. The objective function of the optimization task is to minimize the path length (= accumulated weights), in other word

<math display="block">\arg \min_{x_{ij}} \sum_{i=1}^{N} \sum_{j=1,~j \neq i}^{N} c_{ij} x_{ij} ~j = 1, \ldots, N.</math>

However without further constraints this optimization considers not only paths, which are characterized by also leaving each reached vertex, but all set of edges enabling the minimum being at <math display="inline">x_{ij}=0</math> for every <math display="inline">i,j \in \mathcal{V}</math>. Therefore further constraints are necessary to ensure that paths are considered and each vertex is visited exactly once. These requirements can be forced by formulating the following further two constraints, which force that the path reaches each vertex exactly once and leaves each vertex exactly once <math display="block">\begin{aligned}
\sum_{i=1,~i \neq j}^{N} x_{ij} = 1, ~~ j = 1, \ldots, N, \\
\sum_{j=1,~j \neq i}^{N} x_{ij} = 1, ~~ i = 1, \ldots, N.
\end{aligned}</math>

These constraints ensure that the selected way looks locally as path and all vertices are visited, but still allow that the selected set of edges comprises several local paths each of them visiting only a disjunct subset of vertices instead of one global path visiting every vertices. This global path requirement makes TSP a difficult problem. There are more ways to formulate this global path requirement as a linear constraint. The Miller-Tucker-Zemlin formulation introduces dummy variables <math display="inline">u_i</math> for keeping track the order of visit the city <math display="inline">i</math>, for <math display="inline">i = 1, \ldots, N</math>. The path starts with visiting city <math display="inline">1</math>. The global path requirement is ensured by forcing <math display="inline">u_j</math> being higher than <math display="inline">u_i</math> when city <math display="inline">i</math> is visited before city <math display="inline">j</math>, for <math display="inline">i = 2, \ldots, N</math>. More precisely <math display="inline">u_j</math> must be higher than <math display="inline">u_i</math> at least by one when city <math display="inline">j</math> locates on the path after city <math display="inline">i</math>, and otherwise by a values less than <math display="inline">N</math> to ensure that <math display="inline">x_{ij}=0</math> does not force an unwanted relation between <math display="inline">u_i</math> and <math display="inline">u_j</math>. Since city <math display="inline">1</math> is left out from these constraint, it ensures that the optimal path must return to city <math display="inline">1</math>, otherwise the value of the dummy variable of the city visited after city <math display="inline">N-1</math> would be less that <math display="inline">u_{N-1}</math>, which would violate the constraint. The city <math display="inline">1</math> is the only one for which a decrease in value of the dummy variable allowed when the path reaches city <math display="inline">1</math>. These considerations lead to the formulation of the global path requirement as a linear constraint as <math display="block">u_i -u_j + 1 \leq (N-1)(1-x_{ij}) ~~ i,j \in \{2, \ldots, N \} \mathrm{~and~} i \leq j.</math>

Putting all these together gives the Miller-Tucker-Zemlin ILP formulation of the TSP as <math display="block">\begin{aligned}
\arg \min_{x_{ij}} \sum_{i=1}^{N} \sum_{j=1,~j \neq i}^{N} c_{ij} x_{ij},~\ldots, N, ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~subject~to} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~constraint~}1.~~~ \sum_{i=1,~i \neq j}^{N} x_{ij} = 1, ~~ j = 1, \ldots, N, ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~constraint~}2.~~~ \sum_{j=1,~j \neq i}^{N} x_{ij} = 1, ~~ i = 1, \ldots, N, \mathrm{~and~} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~constraint~}3.~~~ u_i -u_j + 1 \leq (N-1)(1-x_{ij}) ~~ i,j \in \{2, \ldots, N \} \mathrm{~and~} i \leq j.
\end{aligned}</math>


=== Algorithms for TSP ===

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Exact algorithm - Brute-force search'''''

The brute-force search tries all the possible permutations of all the <math display="inline">|V|</math> vertices and selects the one with the lowest accumulated weights. This results in <math display="inline">|V|!</math> different sequence of vertices the <math display="inline">|V|</math> vertices, so the computational complexity of this algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|!)</math>. Hence this approach becomes intractable already for number of cities in the magnitude of <math display="inline">20</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Approximate algorithms'''

Due to the NP-completeness of the TSP the exact solution becomes intractable very fast as the number of cities increases. Therefore there is a need for establishing approximate algorithms for the TSP.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Nearest neighbour algorithm'''''

The Nearest Neighbour (NN) algorithm selects the nearest not yet visited neighbour city at each step. Thus its decision is locally optimal in each step, therefore it is a greedy algorithm. Its schematic representation is shown in Algorithm 5.

 
Algorithm 5 Nearest neighbour approximate algorithm for TSP 
'''—————————————————————————————''' 
Input: Undirected weighted graph. 
Output: Hamiltonian cycle with minimum accumulated weights. 
'''—————————————————————————————''' 
1 Determine <math display="inline">N</math> from graph, <math display="inline">N =|\mathcal{V}|</math> 
2 Initialize <math display="inline">path</math> array, set <math display="inline">path[0]=1</math> and set <math display="inline">totalWeight = 0</math> 
<math display="inline">\mathrm{\ \ }</math> (<math display="inline">path</math> array =sequence of <math display="inline">N</math> vertices) 
3 for <math display="inline">v=1,\ldots N-1</math> 
4 Select nearest not yet visited city among neighbours of city <math display="inline">path[v-1]</math>, <math display="inline">u</math> 
5 <math display="inline">path[v]=u</math> 
6 <math display="inline">totalWeight += weight(path[v-1], u)</math> 
7 end 
8 return <math display="inline">path</math>, <math display="inline">totalWeight</math> 
'''—————————————————————————————''' 

The computational complexity of the NN algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|)</math>. For city arrangement distributed randomly on the plane, the NN algorithms gives a path which is only 25% longer than the shortest one. However for specific city arrangements the NN algorithm can produce also the worst route.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Christofides algorithm'''''

The heuristic approach of Christofides is based on using graph theoretical results to compose an approximate algorithm. It utilizes that a TSP path can not be longer than an Eulerian path over all cities of the graph. Therefore first a subgraph including all cities must be found, than it is extended to be an Eulerian graph, afterwards the Eulerian path is determined in the Eulerian graph and finally it is converted to a TSP path (i.e. to visit each city only once). If the minimum spanning tree of the original graph is selected as first graph and it is made to be an Eulerian graph by doubling every edge in it, then the total length of an Eulerian path can not be more than twice the one of the TSP path. Note that the length of the path changes also at converting the Eulerian path to a TSP path. During this step, shortcut is created for each city visited twice by inserting an edge from the city before this to a city after this. On this way one can approximate a solution for the TSP. The steps of the Christofides algorithm are shown schematically in Algorithm 6.

 
Algorithm 6 Christofides approximate algorithm for TSP 
'''—————————————————————————————''' 
Input: Undirected weighted graph. 
Output: Approximate TSP path. 
'''—————————————————————————————''' 
1 Find a minimum spanning tree <math display="inline">\boldsymbol{T}</math> of the graph. 
2 Duplicate every edges of <math display="inline">\boldsymbol{T}</math> to create an Eulerian graph <math display="inline">\boldsymbol{M}</math> 
3 Find an Eulerian path in <math display="inline">\boldsymbol{M}</math> 
4 Convert Eulerian path to approximate TSP path by using shortcuts 
5 return approximate TSP path 
'''—————————————————————————————''' 

The Christofides algorithm was one of the first approximation algorithm, which shown that establishing an approximation algorithms can be practically usable approach for solving exactly intractable problems.

An improved version of the algorithm is the algorithm of Christofides and Serdyukov, in whic a better way of creating an Eulerian graph is applied. This is done by applying the so called minimum weight matching. The steps of the algorithm of Christofides and Serdyukov can be seen schematically in Algorithm 7.

 
Algorithm 7 Approximate algorithm of Christofides and Serdyukov for TSP 
'''—————————————————————————————''' 
Input: Undirected weighted graph. 
Output: Approximate TSP path. 
'''—————————————————————————————''' 
1 Find a minimum spanning tree <math display="inline">\boldsymbol{T}</math> of the graph. 
2 Apply minimum weight matching to odd-degree vertices of <math display="inline">\boldsymbol{T}</math> giving graph <math display="inline">\boldsymbol{W}</math> 
3 Find optimal Eulerian path in <math display="inline">\boldsymbol{W}</math> 
4 Convert Eulerian path to approximate TSP path by using shortcuts 
5 return approximate TSP path 
'''—————————————————————————————''' 

Approximate algorithm of Christofides and Serdyukov gives an approximate TSP path with accumulated weights, which is at most 1,5 times higher than the one of the optimal TSP path. The computational complexity of the approximate algorithm of Christofides and Serdyukov is <math display="inline">\mathcal{O}(|\mathcal{V}|^3)</math>, which is mainly caused by minimum weight matching algorithm part.


== Shortest path problem ==

The shortest path in a weighted graph between two vertices is the path connecting them with the smallest accumulated weight. There are more algorithm for finding shortest path, each with a slightly different applicability scope.

Besides of Diskstra’s algoritm another common algorithms are the [https://en.wikipedia.org/wiki/Bellman-Ford_algorithm Bellman-Ford] and the [https://en.wikipedia.org/wiki/Floyd-Warshall_algorithm Floyd Warshall] algorithms.


=== Dijkstra-Algorithmus ===

Diskstra’s algorithm finds the shortest path from a given source vertex to every vertices in a weighted graph <math display="inline">\boldsymbol{G}</math>. The graph must not contain negative edge, since in that case the algorithm fails.

The idea of Diskstra’s algorithm is an iterative extension of shortest path tree (SPT) containing a subtree with vertices, for which the shortest paths from the a given source have already been found. The vertices outside of SPT have also minimum distance values assigned during the intermediate steps of the processing. The minimum distance values of vertices being neighbour of any vertices of SPT and locating outside of SPT represent the minimum distance from source vertex to the considered vertex via every possible routes over the vertices of the actual SPT. The iterative extension of SPT is performed by selecting the vertex <math display="inline">u</math> with the shortest minimum distance among the vertices locating outside of SPT, adding this vertex <math display="inline">u</math> together with its minimum distance to SPT and reevaluating the minimum distances of each vertex <math display="inline">v</math> locating outside of the updated SPT and being the neighbour of <math display="inline">u</math>. During the reevaluation the minimum distance of <math display="inline">v</math> is compared to the sum (minimum distance of <math display="inline">v</math> + weight of (<math display="inline">v</math>- <math display="inline">u</math>)) and if the later is smaller then the minimum distance of <math display="inline">v</math> will be updated.

The schematical representation of the algorithm can be seen in Algorithm 8.

 
Algorithm 8 Dijkstra-Algorithmus for determining SPT 
'''—————————————————————————————''' 
Inputs: 
- Undirected weighted connected graph <math display="inline">\boldsymbol{G}</math>. 
- Source vertex <math display="inline">s</math>. 
Output: Array of minimum distances to every vertices <math display="inline">minDist[]</math>. 
'''—————————————————————————————''' 
1 Create an adjacenty matrix <math display="inline">{\bf S}</math> for maintaining SPT with vertices (subtree), 
<math display="inline">\mathrm{\ \ \ }</math>for which the shortest paths from the a given source have already been found 
<math display="inline">\mathrm{\ \ \ }</math>and initialize it to empty. 
<math display="inline">\mathrm{\ \ \ }</math>Matrix <math display="inline">{\bf S}</math> stores already found minimum distance values for its vertices. 
2 Create and adjacency matrix <math display="inline">{\bf A}</math> for representing the graph <math display="inline">\boldsymbol{R}</math> being a 
<math display="inline">\mathrm{\ \ \ }</math>subgraph of <math display="inline">\boldsymbol{G}</math> containing vertices locating outside of SPT 
<math display="inline">\mathrm{\ \ \ }</math>and every edges of them. Matrix <math display="inline">{\bf A}</math> stores also actual values of 
<math display="inline">\mathrm{\ \ \ }</math>minimum distance to every vertices of <math display="inline">\boldsymbol{R}</math>. 
<math display="inline">\mathrm{\ \ \ }</math>Initialize all these distance values to <math display="inline">\infty</math>, and for the source vertex 
<math display="inline">\mathrm{\ \ \ }</math>set the minimum distance to the value <math display="inline">0</math>. 
3 while matrix <math display="inline">{\bf A}</math> is not empty (=not all vertices are moved from it) 
4 take a vertex <math display="inline">u</math> from subgraph matrix <math display="inline">{\bf A}</math> with the smallest minimum distance 
5 add vertex <math display="inline">u</math> with its minimum distance and its edge connecting it to SPT 
6 matrix <math display="inline">{\bf S}</math> 
7 for each vertex <math display="inline">v</math> of graph <math display="inline">\boldsymbol{R}</math> being neighbour of <math display="inline">u</math> 
8 (update minimum distance of vertex <math display="inline">v</math> in matrix <math display="inline">{\bf A}</math>: ) 
9 if minimum distance of <math display="inline">u</math> + weight of (<math display="inline">v</math>- <math display="inline">u</math>) < minimum distance of <math display="inline">v</math> 
10 minimum distance of <math display="inline">v</math> = minimum distance of <math display="inline">u</math> + weight of (<math display="inline">v</math>- <math display="inline">u</math>) 
11 mark edge of <math display="inline">v</math> to <math display="inline">u</math> as edge connecting to SPT 
12 end 
13 end 
14 remove the row of vertex <math display="inline">u</math> from subgraph matrix <math display="inline">{\bf A}</math> 
15 (that means also removing vertex <math display="inline">u</math> from subgraph <math display="inline">\boldsymbol{R}</math>) 
16 end 
17 Build up array <math display="inline">minDist[]</math> from SPT matrix <math display="inline">{\bf S}</math> 
18 return array <math display="inline">minDist[]</math> 
'''—————————————————————————————''' 

The computational complexity of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{V}|))</math>, since finding the vertex in the subgraph <math display="inline">\boldsymbol{R}</math> takes <math display="inline">\mathcal{O}(log(|\mathcal{V}|))</math> operations, which must be done for every vertices. Note that it is the same as <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{E}|))</math> due to <math display="inline">\mathcal{O}(log(|\mathcal{V}|))= \mathcal{O}(log(|\mathcal{E}|))</math>.

The finding the vertex of subgraph <math display="inline">\boldsymbol{R}</math> with the smallest minimum distance can be implemented by the help of priority queue (or Heap). The standard usage of priority queue would overwrite minimum distance in the inserted pair (minimum distance - vertex) for the same vertex always by the minimum distance of the lastly checked edge to that vertex, which is not necessarily the smallest one among every edges. This can be resolved by inserting more copies of the pair (minimum distance - vertex) for the same vertex, since priority queue will take only the one of them with the smallest value of minimum distance.

Dijkstra’s algorithm assumes that in each intermediate step, the minimum distances of the vertices in SPT, are already the final ones, i.e. the shortest paths from the a given source to the vertices of SPT have already been found. This holds with non- negative weight, since in this case a new path to a vertex in SPT via any vertices of outside of SPT would increase the distance by a sum of non-negative weights which then can not be smaller then the distance marked in SPT as the minimum one. However this is not true in case of existence of negative weight, and thus for graphs with negative weights Dijkstra’s algorithm can return higher distance than than the real minimal one, i.e. wrong result. This is illustrated on the graph in Figure [[#fig:exa_graph_neg_weight|11]].

<div id="fig:exa_graph_neg_weight" class="figure">

[[Datei:exa_graph_neg_weight.jpg|460px|thumb|center|Figure 11: Example graph with negative weight]]

</div>
For this graph Dijkstra’s algorithm would give minimum distance for node <math display="inline">2</math> and <math display="inline">4</math> the value <math display="inline">4</math> and <math display="inline">6</math>, which is wrong, since the right value is <math display="inline">3</math> and <math display="inline">5</math>, respectively

Number Theory

2025-03-13T20:31:01Z

2025-03-04T23:09:23Z

SAFFER Zsolt: Die Seite wurde neu angelegt: „ = Metrics in Data Science = == Evaluation metrics for classification == A classification model is evaluated on the test data. The common metrics used to evaluate the model are listed as * Accuracy, * Confusion matrix, * Precision and Recall, * Sensitivity and Specificity, * F1Score and weighted F1, * ROC curve and AUC ROC. Accuracy is the ratio of corr…“

= Metrics in Data Science =


== Evaluation metrics for classification ==

A classification model is evaluated on the test data. The common metrics used to evaluate the model are listed as

* Accuracy,
* Confusion matrix,
* Precision and Recall,
* Sensitivity and Specificity,
* F1Score and weighted F1,
* ROC curve and AUC ROC.

Accuracy is the ratio of correctly classified examples to the total number of examples in the test set. Defining true examples (TE) and false examples (FE) the number of correctly and incorrectly classified examples in the test set, accuracy can be given as

<math display="block">\mathrm{Accuracy} = \frac{TE}{TE+FE}.</math>

The confusion matrix is a metric to visualize the classification performance. The rows of the matrix represent the true classes and the columns shows the predicted classes or vice versa. Both versions are used and can be found in the literature. Here we use the first version. The element (i,j) of the matrix shows the number of test examples belonging to class <math display="inline">i</math> and classified as class <math display="inline">j</math>. Thus besides showing the number of correctly classified examples for each class, the confusion matrix gives an idea of typical missclassifications the model makes. An example confusion matrix can be seen in Figure [[#fig:exa_conf_matrix|16]].

<div id="fig:exa_conf_matrix" class="figure">

[[File:./figs/EvalMetric_ConfMatrExa.pdf]]

</div>
The metrics precision and recall, sensitivity and specificity as well as F1Score and weighted F1 were originally introduced for binary classification models, but their usage can be extended to multiclass case. Therefore they will be defined and explained first for binary classification model.

In terms of binary classification with positive and negative classes, the outcome of the classification task can fall in one of four cases: correctly/incorrectly classified examples belonging to positive/negative class. The prediction is true positive (TP) when a positive example is correctly classified, like e.g. presence of a disease. A false negative (FN) prediction occurs when a positive example is classified by the model as would belong to negative class. Similarly a true negative (TN) prediction occurs when a negative example is correctly classified. Finally the prediction is false positive (FP) when a negative example is classified as would belong to positive class. These cases are summarized in Table [[#tab:poss_predictions|8]].

<div class="center">

<div id="tab:poss_predictions">

{| class="wikitable"
|+ Possible cases of the outcome of the classification task (=prediction)
|-
! style="text-align: left;"| predicted <math display="inline">\backslash</math> true
! style="text-align: center;"| positive
! style="text-align: center;"| negative
|-
| style="text-align: left;"| positive
| style="text-align: center;"| true positive (TP)
| style="text-align: center;"| false positive (FP)
|-
| style="text-align: left;"| negative
| style="text-align: center;"| false negative (FN)
| style="text-align: center;"| true negative (TN)
|}

</div>

</div>
For the case of binary classification the definition of Accuracy can be given alternatively as <math display="block">\mathrm{Accuracy} = \frac{TP+TN}{TP+TN+FP+FN}.</math>

The terms TP, FN, TN and FP are also used to denote the number of corresponding cases, e.g. TP also denotes the number of true positives.

Precision is the ratio of the correctly classified positive examples to the total number of examples classified as positive:

<math display="block">\mathrm{Precision} = \frac{TP}{TP+FP}.</math>

In contrast to that Recall is the ratio of the correctly classified positive examples to the total number of positive examples: <math display="block">\mathrm{Recall} = \frac{TP}{TP+FN}.</math>

The measures sensitivity and specificity are also commonly used, especially in the healthcare.

Sensitivity is the True Positive Rate (TPR), i.e. the proportion of captured trues and hence it equals to recall. <math display="block">\mathrm{Sensitivity} = \mathrm{TPR} = \frac{TP}{TP+FN} = \mathrm{Recall}.</math>

Specificity is the proportion of the captured negatives, i.e. True Negative Rate (TNR). <math display="block">\mathrm{Specificity} = \frac{TN}{TN+FP}.</math> It follows that <math display="inline">1-Specificity</math> is the False Positive Rate (FPR), i.e. proportion of not captured negatives, which is needed to define the ROC curve (see below).

The F1Score is a harmonic mean of precision and recall and therefore it is a number between <math display="inline">0</math> and <math display="inline">1</math>. <math display="block">\mathrm{F1Score} = F_1 = 2*\frac{Precision*Recall}{Precision+Recall}.</math>

<div class="center">

<div id="tab:use_metrics">

{| class="wikitable"
|+ The usage of the different metrics.
|-
! style="text-align: left;"| Metric
! style="text-align: center;"| When to use ?
|-
| style="text-align: left;"| Accuracy
| style="text-align: center;"| In case of classification problem
|-
| style="text-align: left;"|
| style="text-align: center;"| with balanced classes.
|-
| style="text-align: left;"| Precision
| style="text-align: center;"| When it is important to be sure about the
|-
| style="text-align: left;"|
| style="text-align: center;"| positive prediction to avoid any negative
|-
| style="text-align: left;"|
| style="text-align: center;"| consequences, like e.g in case of decrease
|-
| style="text-align: left;"|
| style="text-align: center;"| of credit limit to avoid customer dissatisfaction.
|-
| style="text-align: left;"| Recall
| style="text-align: center;"| When it is important to capture positive even
|-
| style="text-align: left;"|
| style="text-align: center;"| with low probability, like e.g. to predict
|-
| style="text-align: left;"|
| style="text-align: center;"| whether a person has illness or not.
|-
| style="text-align: left;"| Sensitivity
| style="text-align: center;"| If the question of interest is TPR,
|-
| style="text-align: left;"|
| style="text-align: center;"| i.e. the proportion of the captured positives.
|-
| style="text-align: left;"| Specificity
| style="text-align: center;"| If the question of interest is TNR,
|-
| style="text-align: left;"|
| style="text-align: center;"| i.e. the proportion of the captured negatives.
|-
| style="text-align: left;"| F1Score
| style="text-align: center;"| When both Precision and Recall are important.
|-
| style="text-align: left;"| weighted F1 metric
| style="text-align: center;"| When importance of Precision and Recall
|-
| style="text-align: left;"|
| style="text-align: center;"| against each other can be characterized
|-
| style="text-align: left;"|
| style="text-align: center;"| by weights explicitly .
|-
| style="text-align: left;"| ROC curve
| style="text-align: center;"| It is used for determining probability threshold
|-
| style="text-align: left;"|
| style="text-align: center;"| for deciding the output class of the task,
|-
| style="text-align: left;"|
| style="text-align: center;"| see Figure x.
|-
| style="text-align: left;"| AUC ROC
| style="text-align: center;"| It is used to determine how well the positive class
|-
| style="text-align: left;"|
| style="text-align: center;"| is separated from the negative class.
|}

</div>

</div>
The weighted F1 metric is a refined version of F1Score, in which Precision and Recall can have different weights. <math display="block">\mathrm{ weighted F1} = F_{\beta} = (1+ \beta^2)*\frac{Precision*Recall}{\beta^2 *Precision+Recall},</math>

where Recall has weight <math display="inline">1</math> and <math display="inline">\beta^2</math> is the weight of Precision.

In a multi-class setting the metrics precision and recall, sensitivity and specificity as well as F1Score and weighted F1 metric are calculated first for each class individually and then averaged. This way they quantify the overall classification performance.

The metrics ROC curve and AUC ROC are defined for binary classification task. The Receiver Operating Characteristic (ROC) curve is the True Positive Rate (=Sensitivity) as a function of the False Positive Rate (= <math display="inline">1-Specificity</math>). The Area Under Curve ROC is called AUC ROC. It indicates how well the positive class is separated from the negative class.

The usage of the different metrics are summarized in the Table [[#tab:use_metrics|9]].

<div id="fig:ill_ROC_curve" class="figure">

[[File:./figs/ROC_curve.pdf]]

</div>
Depending on the use case strict, optimal or lenient (= moderate or high) probability threshold can be selected on the ROC curve. This is illustrated in Figure [[#fig:ill_ROC_curve|17]].


== Evaluation metrics for regression ==

The common metrics used for evaluating regression models are are listed here.

* Mean Squared Error (MSE),
* Root Mean Squared Error (RMSE)
* Mean Absolute Error (MAE),
* Mean Absolute Percentage Error (MAPE),
* Coefficient of Determination (COD), R-squared (<math display="inline">R^2</math>),
* modified R-squared,

The Mean Squared Error (MSE) is one of the basic statistic used to evaluate the quality of a regression model. It is the average of the squares of the difference between the real and predicted values, in other words:

<math display="block">\mathrm{MSE} = \frac{1}{K} \sum_{k} (\hat{y}_k - y_k)^2.</math> Less the MSE, better the regression model fits the real values.

A similar measure is the Root Mean Squared Error (RMSE), which is the square root of MSE and thus it is biven as <math display="block">\mathrm{RMSE} = \sqrt{\frac{1}{K} \sum_{k} (\hat{y}_k - y_k)^2}.</math> RMSE is a measure in the same units as the considered variable, which makes it a commonly used measure.

The Mean Absolute Error (MAE) is the average absolute difference between the real and predicted values. <math display="block">\mathrm{MAE} = \frac{1}{K}\sum_{k}|y_k - \hat{y}_k|</math> A nice property of MAE, that it is less likely influenced by extreme values. It is a common measure used in time series analysis as forecast error.

The mean absolute percentage error (MAPE) quantifies the average of the ratio of the average absolute difference between the real and predicted values to the real value as a percentage. Hence the formula of MAPE can be given as <math display="block">\mathrm{MAPE} = 100 \frac{1}{K}\sum_{k}|\frac{y_k - \hat{y}_k}{y_k}|</math> MAPE is is commonly used for evaluating regression models and it is an appropriate metric where the scale of the considered value varies in a broad range. Intuitively it can be interpreted as a kind of relative error. This makes it also suitable to be used as a loss function as an objective in the optimization in regression problems.

The metric Coefficient of Determination (COD) is also referred as R-squared and it is denoted by <math display="inline">R^2</math> or <math display="inline">r^2</math> and pronounced as "R-squared". The coefficient of determination determines the predictable proportion of the variation in the dependent variable, <math display="inline">{\bf y}</math>. Let <math display="inline">\bar{y}</math> denote the mean of the output values, in other words <math display="block">\bar{y} = \frac{1}{K} \sum_{k} y_k).</math>

The coefficient of determination is defined in terms of residual sum of squares, <math display="inline">SS_{\mathrm{res}}</math> and total sum of squares (related to the variance of <math display="inline">{\bf y}</math>), <math display="inline">SS_{\mathrm{tot}}</math>

<math display="block">\begin{aligned}
SS_{\mathrm{res}} &= \sum_{k} ( y_k - \hat{y}_k)^2, \\
SS_{\mathrm{tot}} &= \sum_{k} ( y_k - \bar{y}_k)^2
\end{aligned}</math>

as

<math display="block">R^2 = 1 -\frac{SS_{\mathrm{res}}}{SS_{\mathrm{tot}}}.</math> <math display="inline">R^2</math> as metric quantifies the predictable proportion of the variation in the dependent variable. Its value falls between 0 and 1 with greater values indicating better regression fit.

The metric modified (or adjusted) R-squared is introduced to compensate that <math display="inline">R^2</math> increases when the dimension <math display="inline">{bf y}</math> becomes higher. Denoting the dimension of <math display="inline">{bf y}</math> by <math display="inline">N</math>, the modified R-squared, <math display="inline">\bar{R}^2</math> is defined as

<math display="block">\bar{R}^2 = 1 -\frac{SS_{\mathrm{res}}}{SS_{\mathrm{tot}}}\frac{K-1}{K-N-1} = 1 -(1-R^2)\frac{K-1}{K-N-1}.</math>


== Evaluation metricS for KG ==


=== Quality of KG ===

The two most important quality measures of a KG are

* completeness and
* accuracy.

The completeness refers to evaluate the amount of existing triplets in the KG, while accuracy targets to measure the amounts of correct and incorrect triplets in the KG. After KG completion the resulted extraction graph is considered to be not yet a ready KG. Therefore quality measurement of KG is relevant only after KG refinement.


=== Evaluation metric for KG refinement ===

Usually completeness is measured in recall, precision and F-measure.

The accuracy of the KG, i.e. the amounts of correct and incorrect triplets is evaluated in terms of accuracy and alternatively, or in addition by means of AUC (i.e. the area under the ROC curve).

The accuracy of the KG, <math display="inline">\mu(\mathcal{G})</math> can be also based on the correctness of the individual triplets <math display="inline">t \in \mathcal{T}</math>, which can be assigned by human e.g. based on random sampling. Then <math display="inline">\mu(\mathcal{G})</math> is given by

<math display="block">\mu(\mathcal{G}) = \frac{1}{|\mathcal{T}|} \sum_{t \in \mathcal{T}} \mathbbm{1}_{\{t\}},</math> where <math display="inline">\mathbbm{1}_{\{t\}}</math> is the indicator variable indicating the correctness of the individual triplets <math display="inline">t \in \mathcal{T}</math> by <math display="inline">1</math> otherwise taking the value <math display="inline">0</math>.

In case of human judging, the usual evaluation metric is accuracy or precision together with the total number of judged triplets and errors found.


=== Evaluation metric for link prediction with KG embeddings ===

The used evaluation metric for link prediction with KG embeddings depends on the subtask of link prediction, see in Table [[#tab:Eval_metr_subt_LP|10]].

<div class="center">

<div id="tab:Eval_metr_subt_LP">

{| class="wikitable"
|+ Evaluation metric for subtasks of link prediction
|-
! style="text-align: left;"| '''Subtask'''
! style="text-align: center;"| '''Evaluation metrics'''
|-
| style="text-align: left;"| Entity prediction
| style="text-align: center;"| rank based measures
|-
| style="text-align: left;"| Entity type prediction
| style="text-align: center;"| Macro-<math display="inline">F_1</math> and Micro-<math display="inline">F_1</math>
|-
| style="text-align: left;"| Triple classification
| style="text-align: center;"| accuracy
|}

</div>

</div>
The rank based evaluation metrics for entity prediction include

* Mean Reciprocal Rank (MRR) and
* Hits@K.

Mean reciprocal rank is the average of the reciprocal ranks of the correct entities: <math display="block">MRR = \frac{1}{|\mathcal{Q}_c|}\sum_{q \in \mathcal{Q}_c} \frac{1}{R(q)},</math> where <math display="inline">\mathcal{Q}_c</math> is set of correct entries and <math display="inline">R(q)</math> is the rank of the entry q. Larger the MRR, better the entity prediction and hence also the used KG embedding model.

Hits@k is the proportion of the correct entities in the best k predictions: <math display="block">Hits@k = \frac{|q \in \mathcal{Q}_c|: R(q) < k}{|\mathcal{Q}_c|}.</math> Larger the Hits@k better the entity prediction and hence also the used KG embedding model.

Logic

2025-03-04T23:06:47Z

= Logic =


== Mathematical logic ==

Mathematical logic is the study of logic in mathematics.


=== Propositional logic ===

Propositional logic deals with logical statements, which are directly decidable. For example the logical statement <math display="inline">2 < 4</math> is <math display="inline">True</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Logical operators'''

The mathematical logical operators are listed as

* Negation
* Conjunction
* Disjunction
* Implication
* Double implication

The logical operators are also called as logical connectives.

Negation as logical operator has only one argument, i.e. it concerns only one statement. Negation of a statement is <math display="inline">True</math> if the statement is <math display="inline">False</math>. Negation is also called as NOT operator and it is denoted in mathematical logic as <math display="inline">\neg</math>. For example if <math display="inline">A</math> stands for a statement then <math display="inline">\neg A</math> is <math display="inline">True</math> whenever <math display="inline">A</math> is <math display="inline">False</math> and vice versa.

Th conjunction and disjunction as logical operators have two arguments. Conjunction is also known as AND operator and denoted by <math display="inline">\land</math>. Disjunction is also known as OR operator and denoted by <math display="inline">\lor</math>.

Implication as logical operator has two arguments. It is also known as conditional operator and it is denoted by <math display="inline">\implies</math>. Implication (e.g. <math display="inline">A \implies B</math>) is <math display="inline">True</math> if truth of first argument (<math display="inline">A</math>) implies truth of second argument (<math display="inline">B</math>) or the first argument (<math display="inline">A</math>) is <math display="inline">False</math>.

Double implication as logical operator has two arguments. It is also known as biconditional operator and it is denoted by <math display="inline">\iff</math>. <math display="inline">A \iff B</math> is <math display="inline">True</math> either if both <math display="inline">A</math> and <math display="inline">B</math> are <math display="inline">True</math> or if both are <math display="inline">False</math>. <math display="inline">A \iff B</math> is to be read as <math display="inline">A</math> iff <math display="inline">B</math> or <math display="inline">B</math> if and only if <math display="inline">A</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Truth tables'''

Logical operators can be also given by their truth tables specifying the logical value (<math display="inline">True</math> or <math display="inline">False</math>) of the operator for each possible combinations of the logical values of the arguments of the operator.

The truth table of logical negation is given by Table [[#tab:log_neg|3]].

<div class="center">

<div id="tab:log_neg">

{| class="wikitable"
|+ Logical negation
|-
! style="text-align: center;"| <math display="inline">A</math>
! style="text-align: center;"| <math display="inline">\neg A</math>
|-
| style="text-align: center;"| True
| style="text-align: center;"| False
|-
| style="text-align: center;"| False
| style="text-align: center;"| True
|}

</div>

</div>
The truth tables for logical conjunction (and) and for logical disjunction (or) are given below by Tables [[#tab:log_and|[tab:log_and]]] and [[#tab:log_or|5]].

<div class="center">

<div id="tab:log_or">

{| class="wikitable"
|+ Logical disjunction
|-
! style="text-align: center;"| <math display="inline">A</math>
! style="text-align: center;"| <math display="inline">B</math>
! style="text-align: center;"| <math display="inline">A \land B</math>
|-
| style="text-align: center;"| True
| style="text-align: center;"| True
| style="text-align: center;"| True
|-
| style="text-align: center;"| True
| style="text-align: center;"| False
| style="text-align: center;"| False
|-
| style="text-align: center;"| False
| style="text-align: center;"| True
| style="text-align: center;"| False
|-
| style="text-align: center;"| False
| style="text-align: center;"| False
| style="text-align: center;"| False
|}

</div>

</div>
<div class="center">

<div id="tab:log_or">

{| class="wikitable"
|+ Logical disjunction
|-
! style="text-align: center;"| <math display="inline">A</math>
! style="text-align: center;"| <math display="inline">B</math>
! style="text-align: center;"| <math display="inline">A \lor B</math>
|-
| style="text-align: center;"| True
| style="text-align: center;"| True
| style="text-align: center;"| True
|-
| style="text-align: center;"| True
| style="text-align: center;"| False
| style="text-align: center;"| True
|-
| style="text-align: center;"| False
| style="text-align: center;"| True
| style="text-align: center;"| True
|-
| style="text-align: center;"| False
| style="text-align: center;"| False
| style="text-align: center;"| False
|}

</div>

</div>
The truth table for logical implication and logical double implication is shown in Table [[#tab:log_impl|[tab:log_impl]]] and [[#tab:log_doub_impl|7]], respectively.

<div class="center">

<div id="tab:log_doub_impl">

{| class="wikitable"
|+ Logical double implication
|-
! style="text-align: center;"| <math display="inline">A</math>
! style="text-align: center;"| <math display="inline">B</math>
! style="text-align: center;"| <math display="inline">A \implies B</math>
|-
| style="text-align: center;"| True
| style="text-align: center;"| True
| style="text-align: center;"| True
|-
| style="text-align: center;"| True
| style="text-align: center;"| False
| style="text-align: center;"| False
|-
| style="text-align: center;"| False
| style="text-align: center;"| True
| style="text-align: center;"| True
|-
| style="text-align: center;"| False
| style="text-align: center;"| False
| style="text-align: center;"| True
|}

</div>

</div>
<div class="center">

<div id="tab:log_doub_impl">

{| class="wikitable"
|+ Logical double implication
|-
! style="text-align: center;"| <math display="inline">A</math>
! style="text-align: center;"| <math display="inline">B</math>
! style="text-align: center;"| <math display="inline">A \iff B</math>
|-
| style="text-align: center;"| True
| style="text-align: center;"| True
| style="text-align: center;"| True
|-
| style="text-align: center;"| True
| style="text-align: center;"| False
| style="text-align: center;"| False
|-
| style="text-align: center;"| False
| style="text-align: center;"| True
| style="text-align: center;"| False
|-
| style="text-align: center;"| False
| style="text-align: center;"| False
| style="text-align: center;"| True
|}

</div>

</div>
'''<math display="inline">\mathrm{\ \ \ \ }</math> Logic formulas'''

Logical operators satisfy several laws, which can be formulated as logic formula. They can be proven either directly based on the interpretations of the arising logical operators or by using the truth tables of the arising logical operators.

Below is a list of the fundamental logic formulas. Here <math display="inline">\equiv</math> stands for the equivalence relation.

* Double negation law <math display="block">\begin{aligned}
&\neg (\neg A) \equiv A \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

\end{aligned}</math>
* Identity laws <math display="block">\begin{aligned}
&(A \land True) \equiv A \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&(A \lor False) \equiv A

\end{aligned}</math>
* Domination laws <math display="block">\begin{aligned}
&(A \land False ) \equiv False \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&(A \lor True) \equiv True

\end{aligned}</math>
* Idempotent laws <math display="block">\begin{aligned}
&(A \land A) \equiv A \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&(A \lor A) \equiv A

\end{aligned}</math>
* Commutative laws <math display="block">\begin{aligned}
&(A \land B) \equiv (B \land A) \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&(A \lor B) \equiv (B \lor A)

\end{aligned}</math>
* Associative laws <math display="block">\begin{aligned}
&(A \land B) \land C \equiv A \land (B \land C) \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&(A \lor B) \lor C \equiv A \lor (B \lor C)

\end{aligned}</math>
* De Morgan laws <math display="block">\begin{aligned}
&\neg (A \land B) \equiv \neg A \lor \neg B \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&\neg (A \lor B) \equiv \neg A \land \neg B

\end{aligned}</math>
* Absorption laws <math display="block">\begin{aligned}
&A \land (A \lor B) \equiv A \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&A \lor (A \land B) \equiv A

\end{aligned}</math>
* Negation laws <math display="block">\begin{aligned}
&A \land \neg A \equiv False \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&A \lor \neg A \equiv True

\end{aligned}</math>

'''<math display="inline">\mathrm{\ \ \ \ }</math> Examples'''

''Example 1''

Given the statement <math display="inline">P</math>: The USA is a democratic country. The negation of <math display="inline">P = \neg P</math>: The USA is not a democratic country. 
''Example 2''

Given the statement <math display="inline">S</math>: <math display="inline">x > 3 \implies x - 4 > -2</math>. Is the statement <math display="inline">S</math> <math display="inline">True</math> or <math display="inline">False</math> ? 
If <math display="inline">x > 3</math> then <math display="inline">x-4 > -2</math> is also <math display="inline">True</math>. So the statement <math display="inline">S</math> is <math display="inline">True</math>.


=== Predicate logic in mathematics ===

Propositional logic deals with statements, whose logical value <math display="inline">True</math> or <math display="inline">False</math> is directly decidable. More interesting are the statements, whose logical value depends on variables. Predicate logic deals with logical statements over a set of variables.

The elements of predicate logic are given as

* Predicate
* Variable domain
* Quantifier

'''<math display="inline">\mathrm{\ \ \ \ }</math> Predicate'''

A predicate is a logical statement whose logical value (<math display="inline">True</math> or <math display="inline">False</math>) depends on one or more variables. Thus formally a predicate is a function with codomain <math display="inline">\{True,False\}</math> and with any set as domain. For predicates tipically a function like notation is used with uppercase letter, like e.g. <math display="inline">P(x)</math>, where <math display="inline">x</math> is the variable it depends on. The predicate is defined by giving a statement involving the variables. For example the predicate <math display="inline">P(x)</math> can be defined as "<math display="inline">P(x)</math> is the statement: x can be divided by 3". Then <math display="inline">P(9)</math> is <math display="inline">True</math> while <math display="inline">P(8)</math> is <math display="inline">False</math>. Just like functions, predicates can also depend on more variables. For example for the predicate <math display="inline">Q(x,y)</math> "defined as <math display="inline">y = x^3+1</math>" <math display="inline">Q(3,28)</math> is <math display="inline">True</math>, since <math display="inline">3^3+1 = 28</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Variable domain'''

Besides of involving variables, the definition of a predicate, just like in case of functions, must involve also the domains of the involved variables. So the definition of predicate <math display="inline">P(x)</math> can be completed as <math display="block">P(x): x \mathrm{~can~be~divided~by~} 3, \mathrm{~where~} x \in \mathbb{N}.</math>

'''<math display="inline">\mathrm{\ \ \ \ }</math> Quantifier'''

Often rather a kind of aggregation of the predicate’s truth values is interesting, instead of the concrete logical value of a predicate for a specific value. For example "every negative real number <math display="inline">x</math> satisfies the inequality <math display="inline">x^3-3x^2+3x-1 < 0</math>" is not a statement for one specific value of <math display="inline">x</math>, but rather about all possible values of negative <math display="inline">x</math>-s.

Such aggregations of the predicate’s truth values are represented by the quantifier of a variable. Thus the quantifier modifies the statement of the predicate by specifying the way of interpretation of the variable, to which the quantifier refers to. The two types of quantifiers are called as

* Existential quantifier,
* Universal quantifier

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Existential quantifier''''' 
The existential quantifier specifies the interpretation of the variable by the concept "there exist an element in the domain of the variable which fulfils the given predicate". The existential quantifier is denoted by <math display="inline">\exists</math>. 
''Example'' The statement <math display="inline">\exists x \in \mathbb{Z}, x < 0</math> is to be interpreted as "there exists an integer number x which is less than zero" . This statement is <math display="inline">True</math>, since for example for <math display="inline">x_0 = -1</math> holds that <math display="inline">x_0 < 0</math>.

The formalism <math display="inline">\exists x \in \mathbb{Z}, x < 0</math> can be also interpreted as an abbreviation for a big OR, which runs over every possible values for <math display="inline">x</math> in the set <math display="inline">\mathbb{Z}</math> and tests <math display="inline">x < 0</math>, in other words

<math display="block">\ldots \lor (-2 < 0) \lor (-1 < 0) \lor (0 < 0) \lor (1 < 0) \lor (2 < 0) \lor \ldots</math>

In Python there is an in-built function any() which realizes the existential quantifier. For example <math display="block">\begin{aligned}
&\mathrm{strs~}=[\mathrm{'Monday}, \mathrm{'Friday'}, \mathrm{'Sunday'}] \\
&\mathrm{any}([s[0] == \mathrm{'F'~for~}s\mathrm{~in~strs}])
\end{aligned}</math> would return <math display="inline">True</math>, due to the string ’Friday’.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Universal quantifier''''' 
The universal quantifier represents the concept "every element in the domain of the variable fulfils the given predicate". The existential quantifier is denoted by <math display="inline">\forall</math>. 
''Example'' The statement <math display="inline">\forall x \in \mathbb{Z}, x < 0</math> is to be interpreted as "every integer number x is less than zero" . This statement is <math display="inline">False</math>, since for example for <math display="inline">x_1 = 1</math> does not hold that <math display="inline">x_1 < 0</math>.

The formalism <math display="inline">\forall x \in \mathbb{Z}, x < 0</math> can be also interpreted as an abbreviation for a big AND, which runs over every possible values for <math display="inline">x</math> in the set <math display="inline">\mathbb{Z}</math> and tests <math display="inline">x < 0</math>, in other words

<math display="block">\ldots \land (-2 < 0) \land (-1 < 0) \land (0 < 0) \land (1 < 0) \land (2 < 0) \land \ldots</math>

In Python there is an in-built function also for all() which realizes the universal quantifier. For example, for the previously defined list of strings one can test <math display="inline">s[3]</math> as <math display="block">\begin{aligned}
&\mathrm{strs~}=[\mathrm{'Monday}, \mathrm{'Friday'}, \mathrm{'Sunday'}] \\
&\mathrm{any}([s[3] == \mathrm{'d'~for~}s\mathrm{~in~strs}])
\end{aligned}</math> would return <math display="inline">True</math>, since the fourth letter of all the three strings in the list is ’d’.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Formula and sentence'''

The general formula in the predicate logic is built up from the following elements

* predicates (including the domains of the involved variables)
* propositional operators <math display="inline">\neg</math>, <math display="inline">\land</math>, <math display="inline">\lor</math>, <math display="inline">\implies</math> and <math display="inline">\iff</math>
* the existential and universal quantifiers

A variable is quantified if there is a quantifier referring to it. A sentence is a special case of formula, in which all variables are quantified. The quantified and unquantified variables are also referred as bound and free variables, respectively.

For example the formula <math display="block">\forall x \in \mathbb{N}, x^4 < y</math> is not a sentence, since the variable <math display="inline">y</math> is not quantified. After quantifying also <math display="inline">y</math> we get the sentence <math display="block">\forall x,y \in \mathbb{N}, x^4 < y</math>

Valid places for comma for arising in predicate formulas are given as

* separating variables in the same quantification,
* immediatly after the quantification and
* seperating arguments in predicate function.

An example for a predicate formula built up from all the three types of elements is given as <math display="block">\forall x,y \in \mathbb{N}, \exists z \in \mathbb{Z} , P(x,y) \implies R(x,y,z)</math>

'''<math display="inline">\mathrm{\ \ \ \ }</math> Simplification rules''' 

Taking a negation of a statement is very common in practice. However usually it is not easy to interpret and understand negation of formulas. In this case simplification rules can be applied in order to push the negation to right. Below is a list of useful simplification rules with negation.

* Double negation law <math display="block">\begin{aligned}
&\neg (\neg P) \equiv P \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}

\end{aligned}</math>
* De Morgan laws <math display="block">\begin{aligned}
&\neg (P \land Q) \equiv \neg P \lor \neg Q \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&\neg (P \lor Q) \equiv \neg P \land \neg Q

\end{aligned}</math>
* Negation rules for <math display="inline">\implies</math> and <math display="inline">iff</math> <math display="block">\begin{aligned}
&\neg (P \implies Q) \equiv P \land (\neg Q) \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&\neg (P \iff Q) \equiv (P \land (\neg Q)) \lor ((\neg P) \land Q)

\end{aligned}</math>
* Negation rules for quantifiers <math display="block">\begin{aligned}
&\neg (\exists x \in \mathbb{S}, P(x)) \equiv \forall x \in \mathbb{S}, \neg P(x) \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&\neg (\forall x \in \mathbb{S}, P(x)) \equiv \exists x \in \mathbb{S}, \neg P(x)

\end{aligned}</math>


== First-order logic ==

First-order logic, also called predicate logic, is used not only in mathematics, but also in philosophy, linguistics and computer science. First-order logic allows sentences containing quantified variables. In first-order logic sentences are formulated by means of predicate, like e.g. "For every x, if x has a son, then x is parent".


=== Description of first-order formulas ===

In this subsection we give a brief overview on the description of the first-order logic. The description of first-order logic requires the introduction of infinite sets like terms and formulas, which are defined inductively.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Elements of first-order logic'''

The elements of first-order formulas are given as

* Variables, like x,y, representing any objects, i.e. whose meaning is determined by the semantic.
* Functions, where function with <math display="inline">n</math> arguments are called <math display="inline">n</math>-ary functions.
* Predicates, where predicates with <math display="inline">n</math> arguments are called <math display="inline">n</math>-ary predicates.
* Equality
* Logical operators or logical connectives

'''<math display="inline">\mathrm{\ \ \ \ }</math> Terms'''

The infinite set of terms is defined by applying the following rules

* <math display="inline">{\bf T1.}</math> Variables. Any variable symbol itself is a term.
* <math display="inline">{\bf T2.}</math> Functions. If <math display="inline">f()</math> is a n-ary function and <math display="inline">t_1,\ldots, t_n</math> are terms then applying <math display="inline">f()</math> to these terms, <math display="inline">f(t_1,\ldots, t_n)</math> is also a term.

Terms are only the expressions, which can be obtained by finite many application of rules <math display="inline">{\bf T1.}</math> and <math display="inline">{\bf T2.}</math> are terms.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Formulas'''

The infinite set of formulas is defined by applying the following rules

* <math display="inline">{\bf F1.}</math> Predicate. If <math display="inline">P()</math> is a n-ary predicate and <math display="inline">t_1,\ldots, t_n</math> are terms then applying <math display="inline">P()</math> to these terms, <math display="inline">P(t_1,\ldots, t_n)</math> is a formula
* <math display="inline">{\bf F2.}</math> Equality. If <math display="inline">t_1</math> and <math display="inline">t_1</math> are terms then the equality symbol applied to them, <math display="inline">t_1=t_2</math> is a formula.
* <math display="inline">{\bf F3.}</math> Negation. If <math display="inline">\Psi</math> is a formula then <math display="inline">\neg \Psi</math> is also a formula.
* <math display="inline">{\bf F4.}</math> Binary logical operators. If <math display="inline">\Psi</math> and <math display="inline">\Phi</math> are formulas then any binary logical functions of them (like e.g. <math display="inline">\Psi \land \Phi</math>, <math display="inline">\Psi \implies \Phi</math>, etc. ) is also a formula.
* <math display="inline">{\bf F5.}</math> Quantifiers. If <math display="inline">\Psi</math> is a formula and x is a variable then <math display="inline">\forall x \Psi</math> and <math display="inline">\exists x \Psi</math> are also formulas.

The expressions obtained by finite many applications of only rules <math display="inline">{\bf F1.}</math> and <math display="inline">{\bf F2.}</math> are called atomic formulas. Formulas are only the expressions, which can be obtained by finite many applications of the rules <math display="inline">{\bf F1.}</math> - <math display="inline">{\bf F5.}</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Precedence of the logical operators'''

Precedence of the logical operators enables to interpret a formula without placing any parentheses into it. The precedence of the logical operators in decreasing order is given by

* Negation
* Disjunction and conjunction
* Quantifiers
* Implication

Nevertheless extra parentheses can be inserted into formulas.


=== Formal description of first-order logic ===

Description of first-order logic as language is completely formal. The terms and formulas are strings of symbols, the symbols together forms the alphabet of the language.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Alphabet'''

The alphabet of symbols can be divided into the following two groups:

* Logical symbols
* Non-logical symbols

The logical symbols include the infinite set of variables, the logical operators, the quantifier symbols, parenthesis, brackets and other punctuation sybols as well as the equality symbol.

The non-logical symbols include the infinite set of n-ary predicate symbols (like e.g. <math display="inline">P^2_i</math>, <math display="inline">i \geq 0</math> for binary predicate symbols) and the infinite set of n-ary function symbols (like e.g. <math display="inline">f^3_i</math>, <math display="inline">i \geq 0</math> for ternary function symbols)

'''<math display="inline">\mathrm{\ \ \ \ }</math> Language of syntactically valid first-order formulas'''

Based on the alphabet, the inductive definition of terms, atomic formulas and formulas the language of syntactically valid first-order formulas can be defined as a cntext-free grammar. This can be seen in Backus-Naur form in Figure [[#fig:Lang_folf_cfg_BNF|15]].

<div id="fig:Lang_folf_cfg_BNF" class="figure">

[[File:./figs/Language_first_order_logic_BNF_grammar.pdf]]

</div>

=== Semantics ===

Semantic meaning of a first-order language is determined by its interpretation. This interpretation - assigns a way of interpretation to each non-logical symbol in that language and - determines the domains of variables.


=== Deductive systems ===

Deductive system is to show on syntactic level, that one formula logically follows from another formula.

The deductive system is sound if every formula which can be derived in the system is logically valid. On the other hand a deductive system is complete if every logically valid formula can be derived in it.

An important property of the deductive systems that they are completely syntactic, so no any interpretation is utilized for the derivations in such system. This means that if the deductive system is sound, than it holds in every possible interpretation of the language describing the system.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Rule of inference'''

The rule of inference represents the concept that from a given formula (set of formulas) another formula (set of formulas) can be derived as a conclusion.

One commonly used rule of inference is the rule of substitution. Let <math display="inline">t</math> and <math display="inline">\Psi(x)</math> be a term and a formula containing the variable <math display="inline">x</math> respectively. Then replacing all free instances of <math display="inline">x</math> by <math display="inline">t</math> in the formula <math display="inline">\Psi(x)</math> is denoted by <math display="inline">\Psi[t/x]</math>. The rule of substitutions states that for any <math display="inline">\Psi(x)</math> and <math display="inline">t</math> it can be concluded that <math display="inline">\Psi[t/x]</math>, given the condition that no free variable of <math display="inline">t</math> becomes bound during the substitution process.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Formula identities'''

Besides of the simplification rules provided in [[#simpl_rules|[simpl_rules]]] several further useful formula identities are listed below.

* Commutativity of the same quantifier <math display="block">\begin{aligned}
&\forall x \forall y P(x,y) \equiv \forall y \forall x P(x,y) \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&\exists x \exists y P(x,y) \equiv \exists y \exists x P(x,y)

\end{aligned}</math>
* Quantifier with disjunction and conjunction - distributivity <math display="block">\begin{aligned}
&\forall x P(x) \land \forall x Q(x) \equiv \forall x (P(x) \land Q(x)) \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&\exists x P(x) \lor \exists x Q(x) \equiv \exists x (P(x) \lor Q(x))

\end{aligned}</math>
* Quantifier with disjunction and conjunction - exchangeability <math display="block">\begin{aligned}
&P \land \exists x Q(x) \equiv \exists x (P \land Q(x)) \mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\ %\mathrm{~~where~}x\mathrm{~must~not ~occur~free~in}P
&P \lor \forall x Q(x) \equiv \forall x (P \lor Q(x)) %\mathrm{~~where~}x\mathrm{~must~not ~occur~free~in}P

\end{aligned}</math>


=== Applications of first-order logic ===

First-order logic has applications in different scientific fields. Some of them are given below.

* In mathematics it is used for formalizing and provides proof techniques for mathematical theorems.
* In computer science it is used for logical reasoning and verifying computer programs.
* In linguistic it is used for formalizing simple quantifier construction in natural language, which serves a basis for knowledge representation languages.

Graph Theory and Algorithms

2025-03-04T23:04:20Z

SAFFER Zsolt:

,
= Graph Theory and Algorithms =

For a comprehensive subject on graph theory the reader is referred to the book [Gross and Yellen(1998)].


== Seven Bridges of Königsberg ==

Seven Bridges of Königsberg is a problem of mathematics formulated by Leonhard Euler after a walk in Königsberg in Prussia (now Kaliningrad, Russia). The islands were connected to each other and the mainlands on the two sides of the Pregel River via seven bridges (see Figure [[#fig:Königsberg_bridges|2]]).

<div id="fig:Königsberg_bridges" class="figure">

[[File:./figs/Konigsberg_bridges.png]]

</div>
The problem is to find a walk path that would cross each of the seven bridges only once.

Leonhard Euler has resolved the problem in 1736 by showing that such a walk path does not exist. His solution founded the graph theory and therefore the Seven Bridges of Königsberg problem is considered to be the first problem of graph theory.


== Graphs theory basics ==

A graph is a mathematical object consisting of vertices (nodes) and edges connecting pairs of vertices, see example in Figure [[#fig:exa_undirected_graph|3]].

<div id="fig:exa_undirected_graph" class="figure">

[[File:./figs/exa_undirected_graph.pdf]]

</div>
Graph theory studies properties of graphs and problems which can be described by means of graphs. Graph theoretical algorithms and results are applied in many areas, like e.g. transport networks, computer science or biology.


=== Basics ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Basic terms'''

A graph is composed of vertices (nodes) and edges connecting pairs of vertices. Vertex and edge are the two basic units of the graph. The set of vertices and edges is denoted by <math display="inline">\mathcal{V}</math> and <math display="inline">\mathcal{E}</math>, respectively. In undirected graph the edges have no direction, they simple connect two vertices. The graph shown in Figure [[#fig:exa_undirected_graph|3]] is an example of an undirected graph.

The degree of a vertex is the number of edges connected to it. A path is an uninterrupted line connecting two vertices over sequence of edges and vertices. For example the path <math display="inline">(1,2,5,6)</math> in Figure [[#fig:exa_undirected_graph|3]] connects the vertices <math display="inline">1</math> and <math display="inline">6</math>. This way a path is specified by an ordered list of all vertices locating on the uninterrupted line going from the starting vertex of the path to the end vertex of it. A cycle is a path, whose start vertex and end vertex is the same. For example <math display="inline">(1,2,3,4,1)</math> in Figure [[#fig:exa_undirected_graph|3]] is a cycle. A graph is called connected graph, if there is a path between any two vertices of the graph. For example the graph in Figure [[#fig:exa_undirected_graph|3]] is a connected graph.

In the weighted graph each edge has a weight (or cost) associated to them. This weight can represent different physical properties, like e.g. distance between two nodes, capacity of a network link, transport cost of a way between two nodes, etc. An example of a weighted graph can be seen in Figure [[#fig:exa_weighted_graph|4]].

<div id="fig:exa_weighted_graph" class="figure">

[[File:./figs/exa_weighted_graph.pdf]]

</div>
'''<math display="inline">\mathrm{\ \ \ \ }</math> Types of graphs'''

The classification of graphs into various types is based on the properties of the considered subclass of graphs. The most important types of graphs together with their definitions are given as follows.

* Undirected graph - A graph with edges having no direction.
* Directed graph - A graph with edges having direction.
* Unweighted graph - A graph with edges having no weights associated to them.
* Weighted graph - A graph with edges having weights associated to them.
* Connected graph - A graph having path between any two of its vertices.
* Disconnected graph - A graph containing at least one pair of vertices having no path between them.
* Cyclic graph - A graph containing at least one cycle.
* Acyclic graph - A graph does not containing any cycles.
* Tree - A connected acyclic graph.
* Multi-graph - A graph containing at least one pair of vertices having multiple edges between them.
* Simple graph - A graph without cycles and multiple edges between the same pair of vertices.
* Complete graph - A graph in which each pair of vertices is connected by edge.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Graph descriptions'''

The most often used graph representations in algorithms are

* adjacency matrix and
* adjacency list,

because they enable the mathematical description of graphs by means of programming variables, like matrix, array and list.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Adjacency matrix'''''

Adjacency matrix is suitable to describe unweighted graphs, both undirected and directed ones. Adjacency matrix is a <math display="inline">V \times V</math> matrix, whose <math display="inline">(i,j)</math>-th element describes the existence of the connection from vertex <math display="inline">i</math> to vertex <math display="inline">j</math> as a binary value. If there is a connection then this value equals <math display="inline">1</math>, otherwise <math display="inline">0</math>. For example the adjacency matrix of the undirected, unweighted graph example in Figure [[#fig:exa_undirected_graph|3]] looks like

<math display="block">\begin{aligned}
\left(
\begin{array}{llllll}
0 & 1 & 0 & 1 & 0 & 0\\
1 & 0 & 1 & 0 & 1 & 0\\
0 & 1 & 0 & 1 & 0 & 0\\
1 & 0 & 1 & 0 & 1 & 0\\
0 & 1 & 0 & 1 & 0 & 1\\
0 & 0 & 0 & 0 & 1 & 0
\end{array}
\right).
\end{aligned}</math>

The construction of the adjacency matrix implies that the adjacency matrix of an undirected graph is always a symmetric matrix. The idea of describing an unweighted graph by constructing an adjacency matrix as 2-dimensional array can be theoretically extended to describe a weighted graph by constructing a 3-dimensional array, in which the third dimension represents the weight assigned to the edge specified by the first two dimensions. Such a 3-dimensional could be called as adjacency tensor.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Adjacency list'''''

Another way of mathematical representation of a graph is the adjacency list. Adjacency list is an array of lists, in which each list specifies a set of neighbours of a vertex assigned to the actual list as index of the array. In describing a weighted graph, the list consists of the comma separated sequence of "ending vertex: weight" pairs, where each such pair specifies an edge to the given ending vertex with the given weight starting from the vertex to which the considered list belongs to. In case of an unweighted graph the list is a comma separated sequence of neighbour vertexes of the vertex to which the considered list belongs to. Therefore this type of representation is suitable to describe both unweighted and weighted graphs. For example the adjacency list of the unweighted graph example in Figure [[#fig:exa_undirected_graph|3]] is given as

<math display="block">\begin{aligned}
\begin{array}{ll}
1: & \{2,4\} \\
2: & \{1,3,5\}\\
3: & \{2,4\} \\
4: & \{1,3,5\} \\
5: & \{2,4,6\} \\
6: & \{5\}
\end{array}.
\end{aligned}</math>

Similarly the adjacency list of the weighted graph example in Figure [[#fig:exa_weighted_graph|4]] can be given as

<math display="block">\begin{aligned}
\begin{array}{ll}
1: & \{2:5,3:2\} \\
2: & \{1:5,3:3,4:4\}\\
3: & \{1:2,2:3,4:1\} \\
4: & \{2:4,3:1,5:3\} \\
5: & \{1:8,4:3\}
\end{array}.
\end{aligned}</math>

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Edge list'''''

Still another way of mathematically describing a graph is to specify it as edge list. Each edge is specified by a sequence in the form <math display="inline">[</math> starting vertex, ending vertex, weight (optional) <math display="inline">]</math>. Thus the edge list can be given as a two/three column matrix for unweighted/weighted graphs. Hence this type of representation is suitable to describe both unweighted and weighted graphs. The unweighted graph in Figure [[#fig:exa_undirected_graph|3]] and the weighted graph in Figure [[#fig:exa_weighted_graph|4]] can be described by edge list, respectively, as

<math display="block">\begin{aligned}
&&[ [1,2], [2,3], [1,4], [4,5], [2,5], [3,4], [5,6] ] \\
&&[ [1,2,5], [2,3,3], [3,1,2], [2,4,4], [4,3,1], [1,5,8], [4,5,3] ].
\end{aligned}</math>


=== Graph problems ===

Graph theory can be applied for solving different problems in many areas. Without claim for completeness we list several well-known graph problems with their brief description.

* Graph coloring - Graph coloring is a group of problems all of them having something to do with coloring of graphs. Usually they are specified by means of a restriction on the way of coloring, like e.g no adjacent vertices may have the same color. One of the famous result in graph coloring is the so called [https://en.wikipedia.org/wiki/Four_color_theorem Four-color theorem]
* Network flow problems - Network flow problems deal with question related to [https://en.wikipedia.org/wiki/Flow_network Flow networks].
* Covering problems - Covering problems are set cover problems dealing with covering some subsets of vertices/subgraphs. Vertex cover problem is a special case of set cover problems, in which for every edge its starting or end vertex is in the vertex cover.
* Route problems - Route problems are graph problems, which are all related to find a route specified by various constraints on the graph.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Route problems''' 
Route problems form an important class of graph problems, since they have applications in many areas. Here is a list of several selected Route problems, which will be discussed in more details in the rest of this section.

# Hamiltonian path and Eulerian path
# Traveling salesman problem
# Chinese postman problem (Route inspection problem)
# Minimum spanning tree
# Shortest path problem


== Minimum Vertex Cover Problem ==

Vertex cover problem is a kind of set cover problems, in which a set of vertices are searched, which includes at least one endpoint of every edge of the graph. The Minimum Vertex Cover Problem (MIN-VC) is a vertex cover problem on undirected graph, in which a set of minimum number of vertices are searched, which includes at least one endpoint of every edge of the graph.

<div id="fig:exa_graph_minvc" class="figure">

[[File:./figs/exa_graph_minvc.pdf]]

</div>
For example the minimum vertex cover of the example graph in Figure [[#fig:exa_graph_minvc|5]] is <math display="inline">\{2,3,4\}</math> or <math display="inline">\{2,3,5\}</math> or <math display="inline">\{2,4,5\}</math> or <math display="inline">\{1,3,5\}</math>.

The MIN-VC is an optimization problem and it can be reformulated to a decision problem, which is also called as "vertex cover problem". It is known to be [https://en.wikipedia.org/wiki/NP-completeness NP-complete] (nondeterministic polynomial-time complete), so usually so it cannot be solved by a polynomial-time algorithm.

There is an approximate algorithm for determining the minimum vertex cover of an undirected graph. Its schematic representation is shown in Algorithm 1.

 
Algorithm 1 Approximate algorithm for MIN-VC 
'''—————————————————————————————''' 
Input: Undirected graph given by an edge list (= set <math display="inline">\mathcal{E}</math>). 
Output : Found set of vertex cover <math display="inline">\mathcal{C}</math>. 
'''—————————————————————————————''' 
1 Initialise set of vertex cover: <math display="inline">\mathcal{C}</math>=<math display="inline">\{\}</math> 
2 while <math display="inline">\mathcal{E}</math> is not empty 
3 Take an arbitrary edge <math display="inline">(u,v)</math> from set <math display="inline">\mathcal{E}</math> 
4 Add <math display="inline">u</math> and <math display="inline">v</math> to <math display="inline">\mathcal{C}</math> 
5 Remove all edges from set <math display="inline">\mathcal{E}</math> having endpoint either <math display="inline">u</math> or <math display="inline">v</math> 
6 end 
'''—————————————————————————————''' 

It can be proven that the above approximate algorithm for MIN-VC always finds a vertex cover whose size is not more than twice of the size of the minimum vertex cover. The computational complexity of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|+|\mathcal{E}|)</math>. The memory need of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|</math> The memory is needed to store the visited vertices, i.e. the set <math display="inline">\mathcal{C}</math>.


== Eulerian path and Hamiltonian path ==


=== Eulerian path and cycle ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Eulerian path'''

Eulerian path in an undirected graph <math display="inline">\boldsymbol{G}</math> is a path that visits every edges of <math display="inline">\boldsymbol{G}</math> exactly once. Note that the undirected graph <math display="inline">\boldsymbol{G}</math> can be unweighted or weighted. However this does not affect the mathematical treatment of Eulerian path, therefore we treat these cases commonly by simple omitting unweighted or weighted characterization of <math display="inline">\boldsymbol{G}</math>.

The necessary and sufficient conditions for for the existence of Eulerian path in the undirected graph <math display="inline">\boldsymbol{G}</math> can be given as

* Every vertices with non-zero degree of <math display="inline">\boldsymbol{G}</math> form a connected graph.
* Either none of the vertices or exactly two vertices of <math display="inline">\boldsymbol{G}</math> have odd degree and all its other vertices have even degree.

Along the Euler path, each time walking through a vertex we walking through two previously unseen edges: one at approaching the vertex and the other at leaving it. On this way the number of edges at each middle vertex (i.e. the vertices except the starting and ending vertices of the path) must be even. The starting and ending vertices of the path are enabled to have odd degree, as the start or finish of the walk goes through on only one edge connected to that vertices. This argument proves the necessity of the condition. It turns out that the condition is also sufficient.

<div id="fig:exa_graph_E-path" class="figure">

[[File:./figs/exa_graph_E-path.pdf]]

</div>
For example the example graph in Figure [[#fig:exa_graph_E-path|6]] has an Euler path <math display="inline">(1,3,4,5,2,4)</math>, since only vertices <math display="inline">1</math> and <math display="inline">4</math> have odd degree.

An Euler path can be determined by going through the graph starting from a vertex with odd degree and selecting always previously unseen edges at each vertices. The conditions ensure that this always leads to an Euler path. This process requires the logging of the already visited edges at each vertex. It follows that the computational complexity of finding an Euler path is <math display="inline">\mathcal{O}(|\mathcal{V}|^2</math>

The Seven Bridges of Königsberg is a problem of finding an Euler path. In fact Leonard Euler solved it in 1736 by showing that there is no path that visits every of the seven bridges exactly once. His solution applies the above argument for necessary condition. Euler’s solution of the Königsberg bridge problem is the first theorem of graph theory and laid the foundations of graph theory.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Eulerian cycle'''

Eulerian cycle in an undirected graph <math display="inline">\boldsymbol{G}</math> is a closed path that visits every edges of <math display="inline">\boldsymbol{G}</math> exactly once and returns to the starting vertex. Similarly to Eulerian path, the undirected graph <math display="inline">\boldsymbol{G}</math> can be unweighted or weighted, which does not affect of the mathematical treatment of Eulerian cycle. Hence these cases are treated commonly by simple omitting unweighted or weighted characterization of <math display="inline">\boldsymbol{G}</math>. A graph containing a Eulerian cycle is a Eulerian graph.

The necessary and sufficient conditions for the existence of Eulerian cycle in the undirected graph <math display="inline">\boldsymbol{G}</math> can be formulated as

* Every vertices with non-zero degree of <math display="inline">\boldsymbol{G}</math> form a connected graph.
* Every vertices of <math display="inline">\boldsymbol{G}</math> have even degree.

This can be argumented similarly as in case of Eulerian path. Because in case of Eulerian cycle the path returns to the starting vertex, no odd degree is allowed yet for that vertex.

The example graph in Figure [[#fig:exa_graph_E-path|6]] has no Eulerian cycle, since not every vertices have even degree (vertices <math display="inline">1</math> and <math display="inline">4</math> have odd degree).

<div id="fig:exa_graph_E-cycle" class="figure">

[[File:./figs/exa_graph_E-cycle.pdf]]

</div>
However the in the graph in Figure [[#fig:exa_graph_E-cycle|7]] every vertices have even degree, therefore it has a Eulerian cycle, e.g. (1,3,5,6,7,5,4,3,2,1).

Finding a Eulerian cycle can be completed on the same way as described for Eulerian path, but the visit can start at any vertex, since all vertices have even degree. Like in case of finding an Eulerian path, finding a Eulerian cycle has a computational complexity of <math display="inline">\mathcal{O}(|\mathcal{V}|^2</math>.


=== Hamiltonian path and cycle ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Hamiltonian path'''

Hamiltonian path in an undirected graph <math display="inline">\boldsymbol{G}</math> is a path that goes through every vertex of <math display="inline">\boldsymbol{G}</math> exactly once. The path have not to return to the starting vertex, i.e. Hamiltonian path is an open path. Finding a Hamiltonian path is in general an NP-complete problem.

For example the example graph in Figure [[#fig:exa_undirected_graph|3]] has more Hamiltonian paths: <math display="inline">(3,2,1,4,5,6)</math> or <math display="inline">(1,4,3,2,5,6)</math>.

Hamiltonian path has applications in many fields including

* transportation networks (finding optimal routes),
* circuit design and
* graph theory research.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Hamiltonian cycle'''

Hamiltonian cycle (or Hamiltonian circuit) in an undirected graph <math display="inline">\boldsymbol{G}</math> is a closed path that goes through every vertex of <math display="inline">\boldsymbol{G}</math> exactly once and returns to the starting vertex. A graph containing a Hamiltonian cycle is a Hamiltonian graph, otherwise it is non-Hamiltonian graph. Like in case of finding a Hamiltonian path, finding a Hamiltonian cycle is also an NP-complete problem. Finding a Hamiltonian path is often easier than finding a Hamiltonian cycle.

The example graph in Figure [[#fig:exa_undirected_graph|3]] has no Hamiltonian cycle.

<div id="fig:exa_graph_H_cycle" class="figure">

[[File:./figs/exa_graph_H_cycle.pdf]]

</div>
However a slightly different graph in Figure [[#fig:exa_graph_H_cycle|8]] has a Hamiltonian cycle: (5,2,1,4,3,5).

Hamiltonian cycle has applications in many fields including

* computer science,
* logistics and
* network design.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Algorithms for finding Hamiltonian cycle'''

In the next we give a brief description of the following two algorithms for finding Hamiltonian cycle:

* Brute-force search and
* Backtracing algorithm

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Brute-force search - for finding Hamiltonian cycle'''''

The brute-force search (also called exhaustive search) follows a naive approach and tries all the possible permutations of all the <math display="inline">|V|</math> vertices. This results in <math display="inline">|V|!</math> different sequences of the <math display="inline">|V|</math> vertices, so the computational complexity of this algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|!)</math>.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Backtracing algorithm - for finding Hamiltonian cycle'''''

The idea of Backtracing algorithm is to add iteratively a new vertex to the actual path of subsequence of vertices, which is an adjacent to the last vertex of the actual path and not yet included in that path. After having the path with <math display="inline">|\mathcal{V}|</math> vertices, it is checked whether it composes a cycle or not. If not then change the path by trying systematically all the adjacent vertices at every position in the path backwards, which is called backtracking.

The algorithm can be implemented on elegant way by applying a recursive function call. The pseudo code of the algorithm is given in Algorithm 2.

 
Algorithm 2 Backtracing algorithm - for finding Hamiltonian cycle 
'''—————————————————————————————''' 
Input: Undirected graph. 
Output: 
- true, if Hamiltonian cycle found, 
- false, if Hamiltonian cycle exist 
'''—————————————————————————————''' 
1 Initialise path (=sequence of <math display="inline">|\mathcal{V}|</math> vertices) 
2 Set <math display="inline">path[0]</math>= first vertex 
3 if <math display="inline">try\_next\_vertex\_and\_check\_cycle(1)</math> 
4 return <math display="inline">true</math> (cycle found) 
5 else 
6 return <math display="inline">false</math> (cycle not exists) 
7 end 
'''—————————————————————————————''' 
Recursive function 
bool try_next_vertex_and_check_cycle(path_index k) 
Input: next index in the path (=sequence of <math display="inline">|\mathcal{V}|</math> vertices) 
Output: 
- true, if cycle found, 
- false, if backtracking or cycle not exists 
'''—————————————————————————————''' 
1 if <math display="inline">k == |\mathcal{V}|</math> 
2 if exists edge between last and first vertices of path 
3 return <math display="inline">true</math> (cycle found) 
4 else 
5 return <math display="inline">false</math> (backtracking or cycle not exists) 
6 end 
7 for <math display="inline">v \in \mathcal{V}</math> 
8 if <math display="inline">v</math> is adjacent to <math display="inline">path[k-1]</math> (=last vertex in path) 
9 and 
10 <math display="inline">v</math> is not yet in <math display="inline">path[]</math> 
11 path[k]=v 
12 if <math display="inline">try\_next\_vertex\_and\_check\_cycle(k+1)</math> 
13 return <math display="inline">true</math> 
14 end 
15 (Backtracking - remove v from path) 
16 <math display="inline">path[k] = -1</math> 
17 end 
18 end 
19 return false (backtracking or cycle not exists) 
'''—————————————————————————————''' 

In the course of backtracking every neighbours of every vertices can be tried by the algorithm. Therefore its computational complexity is <math display="inline">\mathcal{O}(|\mathcal{V}|!)</math>.


== Chinese postman problem (Route inspection problem) ==

The Chinese postman problem (also called as route inspection problem) is an extension of finding Eulerian cycle in connected and (unweighted or weighted) undirected graphs. The Chinese postman problem is to find shortest path that visits every edge of the connected and undirected graph <math display="inline">\boldsymbol{G}</math> at least once and return to the starting vertex. So the problem is defined on connected graph. The shortest path is defined as the one with minimum number of edges for unweighted graph and as the path with minimum accumulated weights for weighted graph. The solution path of Chinese postman problem is called Chinese postman tour. The Chinese postman problem can be solved in polynomial time.


=== Solution for Eulerian graph ===

If the graph <math display="inline">\boldsymbol{G}</math> contains an Eulerian cycle, then it is also the solution for the Chinese postman problem, since Eulerian cycle has the shortest path (minimum number of edges in unweighted graph and minimum accumulated weights in weighted graph) due to the necessity of visiting all edges at least once.

Therefore the necessary and sufficient condition for the solution for the Chinese postman problem to be the Eulerian cycle is the existence of Eulerian cycle, which can be given as

* Every vertices of <math display="inline">\boldsymbol{G}</math> have even degree.

For example graph in Figure [[#fig:exa_graph_E-cycle|7]] the solution, i.e the Chinese postman tour is the Eulerian cycle, e.g. (1,3,5,6,7,5,4,3,2,1).


=== Solution for Non-Eulerian graph ===

If the graph <math display="inline">\boldsymbol{G}</math> has no Eulerian cycle, then the graph must be extended to become Eulerian. This is done by duplicating some edges of <math display="inline">\boldsymbol{G}</math> connected to vertices with odd degree in order to change the degree of all these vertices become to even. The edges to be duplicated must be selected from the relevant ones (i.e. connected to vertices with odd degree) on that way, that the increase of the path length due to edge duplication must be the possible smallest. Therefore those pairing of the vertices with odd degree are selected, which have the shortest path connecting them.

The example unweighted graph in Figure [[#fig:exa_graph_cpp_unweighted|9]] shows a Non-Eulerian graph and the Chinese postman tour obtained by duplicating the edges [2,4] and [3,1].

<div id="fig:exa_graph_cpp_unweighted" class="figure">

[[File:./figs/exa_graph_cpp_unweighted.pdf]]

</div>
Similarly the example Non-Eulerian weighted graph in Figure [[#fig:exa_graph_cpp_weighted|10]] illustrates the construction of the Chinese postman by duplicating the edges [2,4], [4,6] and [5,1]. Here duplicating [2,4] together with [4,6] instead of [2,6] inserts shorter path (i.e. accumulated weight 2+1= 3 instead of 5). Similarly duplicating [5,1] instead of [5,3] together with [3,1] inserts shorter path (i.e. accumulated weight 1 instead of 1+2=3).

<div id="fig:exa_graph_cpp_weighted" class="figure">

[[File:./figs/exa_graph_cpp_weighted.pdf]]

</div>

=== Algorithm for Chinese postman problem ===

Based on the above considerations the algorithm for finding the Chinese postman route can be given schematically by means of its steps in Algorithm 3.

 
Algorithm 3 Algorithm for Chinese postman problem 
'''—————————————————————————————''' 
Input: Undirected graph <math display="inline">\boldsymbol{G}</math>. 
Output: Chinese postman route. 
'''—————————————————————————————''' 
1 if grap <math display="inline">\boldsymbol{G}</math> is Eulerian 
2 Find an Eulerian cycle in <math display="inline">\boldsymbol{G}</math> 
3 <math display="inline">totalWeight</math> = sum of all edge weights of <math display="inline">\boldsymbol{G}</math> 
4 return Eulerian cycle and <math display="inline">totalWeight</math> 
5 else 
6 Determine <math display="inline">N</math> from graph, <math display="inline">N =|\mathcal{V}|</math> 
7 Find all vertices with odd degree and store in array <math display="inline">oddVertices</math> 
8 Construct the complete graph <math display="inline">\boldsymbol{C}</math> from odd vertices together with edges 
<math display="inline">\mathrm{\ \ \ \ \ }</math>representing shortest paths among any pairs of odd vertices 
9 Find minimum weight perfect matching in <math display="inline">\boldsymbol{C}</math>, i.e the set of edges 
<math display="inline">\mathrm{\ \ \ \ \ }</math> reaching every odd vertices and together having smallest sum of weights. 
<math display="inline">\mathrm{\ \ \ \ \ }</math> This set of edges is called minimum T-join. 
10 Extend the graph <math display="inline">\boldsymbol{G}</math> by adding all edges from minimum T-join 
<math display="inline">\mathrm{\ \ \ \ \ }</math> resulting in extended graph <math display="inline">\boldsymbol{H}</math> 
12 Find an Eulerian cycle in <math display="inline">\boldsymbol{H}</math> 
13 <math display="inline">totalWeight</math> = sum of all edge weights of <math display="inline">\boldsymbol{H}</math> 
14 return Eulerian cycle of <math display="inline">\boldsymbol{H}</math> and <math display="inline">totalWeight</math> 
15 end 
'''—————————————————————————————''' 

The numerical complexity of the above minimum T-join based algorithm for solving the Chinese postman problem is <math display="inline">\mathcal{O}(|\mathcal{V}|^3)</math>, since both setting up the complete graph, and finding minimum weight perfect matching in it takes <math display="inline">\mathcal{O}(|\mathcal{V}|^3)</math> computational steps.


== Minimum spanning tree - Kruskal’s algorithm ==

A spanning tree of a graph is a tree including every vertices of the graph. The number of edges of a spanning tree is <math display="inline">|\mathcal{V}|-1</math>, since the <math display="inline">|\mathcal{V}|</math>-th edge would introduce a cycle and it were not any more a tree.

The minimum spanning tree (MST) is defined for a weighted, undirected, connected graph <math display="inline">\boldsymbol{G}</math>, as a spanning tree with the minimal accumulated weights.

Kruskal’s algorithm can be used to determine the MST of graph <math display="inline">\boldsymbol{G}</math>. In the Kruskal’s algorithm all edges of <math display="inline">\boldsymbol{G}</math> are sorted according to their weights in increasing order. Then the algorithm iteratively adds the next edge from the sorted list, i.e. the edge with the smallest weight, together with their vertexes to MST, if the newly added edge does not induce a cycle. The algorithm proceeds until every edge on the list is checked. On this way the resulted graph will have <math display="inline">|\mathcal{V}|-1</math> edge, so it will be a spanning tree and the way of constructing implies that it will have the least accumulated weights.

The algorithm takes in each step the locally optimal decision due to adding the edge with the smallest weight among the still available ones. Therefore Kruskal’s algorithm is a greedy algorithm.

The algorithm is shown schematically in Algorithm 4.

 
Algorithm 4 Kruskal’s algorithm for detrmining MST 
'''—————————————————————————————''' 
Input: Undirected weighted connected graph <math display="inline">\boldsymbol{G}</math>. 
Output: MST of <math display="inline">\boldsymbol{G}</math>. 
'''—————————————————————————————''' 
1 Initialise graph MST to be set empty. 
2 Sort every edges of <math display="inline">\boldsymbol{G}</math> in increasing weight order and insert them, 
<math display="inline">\mathrm{\ \ }</math> together with their vertexes into array <math display="inline">sortedListEdges[]</math> 
3 for <math display="inline">v=0,\ldots size(sortedListEdges)-1</math> 
4 if inserting <math display="inline">sortedListEdges[v]</math> into MST does not induce a cycle 
5 Add <math display="inline">sortedListEdges[v]</math> into MST 
6 end 
7 end 
8 return MST 
'''—————————————————————————————''' 

The computational complexity of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{E}|))</math>, since sorting the edges has <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{E}|))</math> complexity, iterating through every edges and checking cycle has <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{V}|))</math> and <math display="inline">\mathcal{O}(log(|\mathcal{V}|) =\mathcal{O}(log(|\mathcal{E}|)</math> due to <math display="inline">|\mathcal{E}|</math> is at most <math display="inline">|\mathcal{V}|^2</math>.

The memory need of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|+|\mathcal{E}|)</math>, which is needed to store edges together with their vertexes.


== Traveling salesman problem ==

The Traveling Salesman Problem (TSP) originates from a context of cities and given distances among them. TSP is to look for the shortest path that goes through each city exactly once and returns to the starting city. Usually there exists a route between any pair of cities with some given distance. In graph theory context an equivalent formulation of TSP can be given as looking for a path with the least accumulated weights in a weighted, often complete graph, that goes through each vertex exactly once and returns to the starting vertex. This is equivalent with finding the Hamiltonian cycle with the minimum accumulated weight in a weighted, often complete graph. Thus the TSP is more general than Hamilton cycle problem and hence Hamilton cycle problem is a special case of TSP. The resulted path can be also called as TSP path.

The TSP was formulated mathematically in the 19th century and was first studied mathematically in the 1930s. The decision problem version of TSP is an NP-complete problem, so TSP is NP-hard. TSP is one of the most intensively investigated problem in combinatorial optimization, since it is used as benchmark for other optimization methods in terms of computational complexity.

Some properties of TSP can be provided as

* Symmetric and asymmetric TSP. In symmetric TSP the distance between two cities is the same in both direction, which leads to a formulation in graph theory context to a TSP on undirected graph. In asymmetric TSP either do not exist a path between two cities in both direction or the distances are different excluding the higher one from the TSP formulation. In these cases the formulation in graph theory context yileds a TSP on directed graph.
* Completing the graph by adding edges with sufficiently long distances will not affect the optimal path.
* The path to be a cycle or an open path does not make difference in the computational complexity of TSP (like in case of Hamilton path problem).

The TSP has applications in numerous fields, like logistics, route planning in transport networks, manufacturing of microchips and DNA sequencing. One-way streets, airfares with different departure and arrival fees are real-world scenarios for applying asymmetric TSP.


=== Generalizations of TSP ===

Several generalizations of TSP are listed below.

* The travelling politician problem (also called as "generalized travelling salesman problem") has a context with states having one or more cities and the travelling man must visit exactly one city from each state. It has been shown that travelling politician problem can be led back to standard TSP with modified distance matrix.
* The travelling purchaser problem has a purchaser, who has to buy a set of products, which can be bought in more cities but at different prices. The optimization objective is to find a path among a subset of cities that enables to buy all the products with minimal total cost (=taveling cost + purchasing cost).
* Vehicle routing problem.
* Ring star problem ([Labbé et al.(2004)]).


=== Integer linear programming formulation ===

In order to form the TSP as Integer Linear Programming (ILP) optimization, several variables must be introduced. Let <math display="inline">N</math> denote the number of cities (vertices), i.e. <math display="inline">N = |\mathcal{V}|</math>. Let <math display="inline">c_{ij}</math> stand for the distances (weights) between the cities (vertices) <math display="inline">i</math> and <math display="inline">j</math>, for <math display="inline">i,j = 1, \ldots, N</math>. Let <math display="inline">x_{ij}</math> be a decision variable describing whether the path goes from city (vertix) <math display="inline">i</math> to <math display="inline">j</math>, or not for <math display="inline">i,j = 1, \ldots, N</math>. In other words <math display="block">x_{ij} = \left\{
\begin{aligned}
1, \mathrm{\ \ } \mathrm{~if~path~goes~i \rightarrow j} \\
0, \mathrm{\ \ } \mathrm{~otherwise~~~~~~~~~~~}
\end{aligned}
\right\}.</math> The integer nature of the values <math display="inline">0</math> and <math display="inline">1</math> makes this optimization problem an ILP. The objective function of the optimization task is to minimize the path length (= accumulated weights), in other word

<math display="block">\arg \min_{x_{ij}} \sum_{i=1}^{N} \sum_{j=1,~j \neq i}^{N} c_{ij} x_{ij} ~j = 1, \ldots, N.</math>

However without further constraints this optimization considers not only paths, which are characterized by also leaving each reached vertex, but all set of edges enabling the minimum being at <math display="inline">x_{ij}=0</math> for every <math display="inline">i,j \in \mathcal{V}</math>. Therefore further constraints are necessary to ensure that paths are considered and each vertex is visited exactly once. These requirements can be forced by formulating the following further two constraints, which force that the path reaches each vertex exactly once and leaves each vertex exactly once <math display="block">\begin{aligned}
\sum_{i=1,~i \neq j}^{N} x_{ij} = 1, ~~ j = 1, \ldots, N, \\
\sum_{j=1,~j \neq i}^{N} x_{ij} = 1, ~~ i = 1, \ldots, N.
\end{aligned}</math>

These constraints ensure that the selected way looks locally as path and all vertices are visited, but still allow that the selected set of edges comprises several local paths each of them visiting only a disjunct subset of vertices instead of one global path visiting every vertices. This global path requirement makes TSP a difficult problem. There are more ways to formulate this global path requirement as a linear constraint. The Miller-Tucker-Zemlin formulation introduces dummy variables <math display="inline">u_i</math> for keeping track the order of visit the city <math display="inline">i</math>, for <math display="inline">i = 1, \ldots, N</math>. The path starts with visiting city <math display="inline">1</math>. The global path requirement is ensured by forcing <math display="inline">u_j</math> being higher than <math display="inline">u_i</math> when city <math display="inline">i</math> is visited before city <math display="inline">j</math>, for <math display="inline">i = 2, \ldots, N</math>. More precisely <math display="inline">u_j</math> must be higher than <math display="inline">u_i</math> at least by one when city <math display="inline">j</math> locates on the path after city <math display="inline">i</math>, and otherwise by a values less than <math display="inline">N</math> to ensure that <math display="inline">x_{ij}=0</math> does not force an unwanted relation between <math display="inline">u_i</math> and <math display="inline">u_j</math>. Since city <math display="inline">1</math> is left out from these constraint, it ensures that the optimal path must return to city <math display="inline">1</math>, otherwise the value of the dummy variable of the city visited after city <math display="inline">N-1</math> would be less that <math display="inline">u_{N-1}</math>, which would violate the constraint. The city <math display="inline">1</math> is the only one for which a decrease in value of the dummy variable allowed when the path reaches city <math display="inline">1</math>. These considerations lead to the formulation of the global path requirement as a linear constraint as <math display="block">u_i -u_j + 1 \leq (N-1)(1-x_{ij}) ~~ i,j \in \{2, \ldots, N \} \mathrm{~and~} i \leq j.</math>

Putting all these together gives the Miller-Tucker-Zemlin ILP formulation of the TSP as <math display="block">\begin{aligned}
\arg \min_{x_{ij}} \sum_{i=1}^{N} \sum_{j=1,~j \neq i}^{N} c_{ij} x_{ij},~\ldots, N, ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~subject~to} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~constraint~}1.~~~ \sum_{i=1,~i \neq j}^{N} x_{ij} = 1, ~~ j = 1, \ldots, N, ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~constraint~}2.~~~ \sum_{j=1,~j \neq i}^{N} x_{ij} = 1, ~~ i = 1, \ldots, N, \mathrm{~and~} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~constraint~}3.~~~ u_i -u_j + 1 \leq (N-1)(1-x_{ij}) ~~ i,j \in \{2, \ldots, N \} \mathrm{~and~} i \leq j.
\end{aligned}</math>


=== Algorithms for TSP ===

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Exact algorithm - Brute-force search'''''

The brute-force search tries all the possible permutations of all the <math display="inline">|V|</math> vertices and selects the one with the lowest accumulated weights. This results in <math display="inline">|V|!</math> different sequence of vertices the <math display="inline">|V|</math> vertices, so the computational complexity of this algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|!)</math>. Hence this approach becomes intractable already for number of cities in the magnitude of <math display="inline">20</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Approximate algorithms'''

Due to the NP-completeness of the TSP the exact solution becomes intractable very fast as the number of cities increases. Therefore there is a need for establishing approximate algorithms for the TSP.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Nearest neighbour algorithm'''''

The Nearest Neighbour (NN) algorithm selects the nearest not yet visited neighbour city at each step. Thus its decision is locally optimal in each step, therefore it is a greedy algorithm. Its schematic representation is shown in Algorithm 5.

 
Algorithm 5 Nearest neighbour approximate algorithm for TSP 
'''—————————————————————————————''' 
Input: Undirected weighted graph. 
Output: Hamiltonian cycle with minimum accumulated weights. 
'''—————————————————————————————''' 
1 Determine <math display="inline">N</math> from graph, <math display="inline">N =|\mathcal{V}|</math> 
2 Initialize <math display="inline">path</math> array, set <math display="inline">path[0]=1</math> and set <math display="inline">totalWeight = 0</math> 
<math display="inline">\mathrm{\ \ }</math> (<math display="inline">path</math> array =sequence of <math display="inline">N</math> vertices) 
3 for <math display="inline">v=1,\ldots N-1</math> 
4 Select nearest not yet visited city among neighbours of city <math display="inline">path[v-1]</math>, <math display="inline">u</math> 
5 <math display="inline">path[v]=u</math> 
6 <math display="inline">totalWeight += weight(path[v-1], u)</math> 
7 end 
8 return <math display="inline">path</math>, <math display="inline">totalWeight</math> 
'''—————————————————————————————''' 

The computational complexity of the NN algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|)</math>. For city arrangement distributed randomly on the plane, the NN algorithms gives a path which is only 25% longer than the shortest one. However for specific city arrangements the NN algorithm can produce also the worst route.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Christofides algorithm'''''

The heuristic approach of Christofides is based on using graph theoretical results to compose an approximate algorithm. It utilizes that a TSP path can not be longer than an Eulerian path over all cities of the graph. Therefore first a subgraph including all cities must be found, than it is extended to be an Eulerian graph, afterwards the Eulerian path is determined in the Eulerian graph and finally it is converted to a TSP path (i.e. to visit each city only once). If the minimum spanning tree of the original graph is selected as first graph and it is made to be an Eulerian graph by doubling every edge in it, then the total length of an Eulerian path can not be more than twice the one of the TSP path. Note that the length of the path changes also at converting the Eulerian path to a TSP path. During this step, shortcut is created for each city visited twice by inserting an edge from the city before this to a city after this. On this way one can approximate a solution for the TSP. The steps of the Christofides algorithm are shown schematically in Algorithm 6.

 
Algorithm 6 Christofides approximate algorithm for TSP 
'''—————————————————————————————''' 
Input: Undirected weighted graph. 
Output: Approximate TSP path. 
'''—————————————————————————————''' 
1 Find a minimum spanning tree <math display="inline">\boldsymbol{T}</math> of the graph. 
2 Duplicate every edges of <math display="inline">\boldsymbol{T}</math> to create an Eulerian graph <math display="inline">\boldsymbol{M}</math> 
3 Find an Eulerian path in <math display="inline">\boldsymbol{M}</math> 
4 Convert Eulerian path to approximate TSP path by using shortcuts 
5 return approximate TSP path 
'''—————————————————————————————''' 

The Christofides algorithm was one of the first approximation algorithm, which shown that establishing an approximation algorithms can be practically usable approach for solving exactly intractable problems.

An improved version of the algorithm is the algorithm of Christofides and Serdyukov, in whic a better way of creating an Eulerian graph is applied. This is done by applying the so called minimum weight matching. The steps of the algorithm of Christofides and Serdyukov can be seen schematically in Algorithm 7.

 
Algorithm 7 Approximate algorithm of Christofides and Serdyukov for TSP 
'''—————————————————————————————''' 
Input: Undirected weighted graph. 
Output: Approximate TSP path. 
'''—————————————————————————————''' 
1 Find a minimum spanning tree <math display="inline">\boldsymbol{T}</math> of the graph. 
2 Apply minimum weight matching to odd-degree vertices of <math display="inline">\boldsymbol{T}</math> giving graph <math display="inline">\boldsymbol{W}</math> 
3 Find optimal Eulerian path in <math display="inline">\boldsymbol{W}</math> 
4 Convert Eulerian path to approximate TSP path by using shortcuts 
5 return approximate TSP path 
'''—————————————————————————————''' 

Approximate algorithm of Christofides and Serdyukov gives an approximate TSP path with accumulated weights, which is at most 1,5 times higher than the one of the optimal TSP path. The computational complexity of the approximate algorithm of Christofides and Serdyukov is <math display="inline">\mathcal{O}(|\mathcal{V}|^3)</math>, which is mainly caused by minimum weight matching algorithm part.


== Shortest path problem ==

The shortest path in a weighted graph between two vertices is the path connecting them with the smallest accumulated weight. There are more algorithm for finding shortest path, each with a slightly different applicability scope.

Besides of Diskstra’s algoritm another common algorithms are the [https://en.wikipedia.org/wiki/Bellman-Ford_algorithm Bellman-Ford] and the [https://en.wikipedia.org/wiki/Floyd-Warshall_algorithm Floyd Warshall] algorithms.


=== Dijkstra-Algorithmus ===

Diskstra’s algorithm finds the shortest path from a given source vertex to every vertices in a weighted graph <math display="inline">\boldsymbol{G}</math>. The graph must not contain negative edge, since in that case the algorithm fails.

The idea of Diskstra’s algorithm is an iterative extension of shortest path tree (SPT) containing a subtree with vertices, for which the shortest paths from the a given source have already been found. The vertices outside of SPT have also minimum distance values assigned during the intermediate steps of the processing. The minimum distance values of vertices being neighbour of any vertices of SPT and locating outside of SPT represent the minimum distance from source vertex to the considered vertex via every possible routes over the vertices of the actual SPT. The iterative extension of SPT is performed by selecting the vertex <math display="inline">u</math> with the shortest minimum distance among the vertices locating outside of SPT, adding this vertex <math display="inline">u</math> together with its minimum distance to SPT and reevaluating the minimum distances of each vertex <math display="inline">v</math> locating outside of the updated SPT and being the neighbour of <math display="inline">u</math>. During the reevaluation the minimum distance of <math display="inline">v</math> is compared to the sum (minimum distance of <math display="inline">v</math> + weight of (<math display="inline">v</math>- <math display="inline">u</math>)) and if the later is smaller then the minimum distance of <math display="inline">v</math> will be updated.

The schematical representation of the algorithm can be seen in Algorithm 8.

 
Algorithm 8 Dijkstra-Algorithmus for determining SPT 
'''—————————————————————————————''' 
Inputs: 
- Undirected weighted connected graph <math display="inline">\boldsymbol{G}</math>. 
- Source vertex <math display="inline">s</math>. 
Output: Array of minimum distances to every vertices <math display="inline">minDist[]</math>. 
'''—————————————————————————————''' 
1 Create an adjacenty matrix <math display="inline">{\bf S}</math> for maintaining SPT with vertices (subtree), 
<math display="inline">\mathrm{\ \ \ }</math>for which the shortest paths from the a given source have already been found 
<math display="inline">\mathrm{\ \ \ }</math>and initialize it to empty. 
<math display="inline">\mathrm{\ \ \ }</math>Matrix <math display="inline">{\bf S}</math> stores already found minimum distance values for its vertices. 
2 Create and adjacency matrix <math display="inline">{\bf A}</math> for representing the graph <math display="inline">\boldsymbol{R}</math> being a 
<math display="inline">\mathrm{\ \ \ }</math>subgraph of <math display="inline">\boldsymbol{G}</math> containing vertices locating outside of SPT 
<math display="inline">\mathrm{\ \ \ }</math>and every edges of them. Matrix <math display="inline">{\bf A}</math> stores also actual values of 
<math display="inline">\mathrm{\ \ \ }</math>minimum distance to every vertices of <math display="inline">\boldsymbol{R}</math>. 
<math display="inline">\mathrm{\ \ \ }</math>Initialize all these distance values to <math display="inline">\infty</math>, and for the source vertex 
<math display="inline">\mathrm{\ \ \ }</math>set the minimum distance to the value <math display="inline">0</math>. 
3 while matrix <math display="inline">{\bf A}</math> is not empty (=not all vertices are moved from it) 
4 take a vertex <math display="inline">u</math> from subgraph matrix <math display="inline">{\bf A}</math> with the smallest minimum distance 
5 add vertex <math display="inline">u</math> with its minimum distance and its edge connecting it to SPT 
6 matrix <math display="inline">{\bf S}</math> 
7 for each vertex <math display="inline">v</math> of graph <math display="inline">\boldsymbol{R}</math> being neighbour of <math display="inline">u</math> 
8 (update minimum distance of vertex <math display="inline">v</math> in matrix <math display="inline">{\bf A}</math>: ) 
9 if minimum distance of <math display="inline">u</math> + weight of (<math display="inline">v</math>- <math display="inline">u</math>) < minimum distance of <math display="inline">v</math> 
10 minimum distance of <math display="inline">v</math> = minimum distance of <math display="inline">u</math> + weight of (<math display="inline">v</math>- <math display="inline">u</math>) 
11 mark edge of <math display="inline">v</math> to <math display="inline">u</math> as edge connecting to SPT 
12 end 
13 end 
14 remove the row of vertex <math display="inline">u</math> from subgraph matrix <math display="inline">{\bf A}</math> 
15 (that means also removing vertex <math display="inline">u</math> from subgraph <math display="inline">\boldsymbol{R}</math>) 
16 end 
17 Build up array <math display="inline">minDist[]</math> from SPT matrix <math display="inline">{\bf S}</math> 
18 return array <math display="inline">minDist[]</math> 
'''—————————————————————————————''' 

The computational complexity of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{V}|))</math>, since finding the vertex in the subgraph <math display="inline">\boldsymbol{R}</math> takes <math display="inline">\mathcal{O}(log(|\mathcal{V}|))</math> operations, which must be done for every vertices. Note that it is the same as <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{E}|))</math> due to <math display="inline">\mathcal{O}(log(|\mathcal{V}|))= \mathcal{O}(log(|\mathcal{E}|))</math>.

The finding the vertex of subgraph <math display="inline">\boldsymbol{R}</math> with the smallest minimum distance can be implemented by the help of priority queue (or Heap). The standard usage of priority queue would overwrite minimum distance in the inserted pair (minimum distance - vertex) for the same vertex always by the minimum distance of the lastly checked edge to that vertex, which is not necessarily the smallest one among every edges. This can be resolved by inserting more copies of the pair (minimum distance - vertex) for the same vertex, since priority queue will take only the one of them with the smallest value of minimum distance.

Dijkstra’s algorithm assumes that in each intermediate step, the minimum distances of the vertices in SPT, are already the final ones, i.e. the shortest paths from the a given source to the vertices of SPT have already been found. This holds with non- negative weight, since in this case a new path to a vertex in SPT via any vertices of outside of SPT would increase the distance by a sum of non-negative weights which then can not be smaller then the distance marked in SPT as the minimum one. However this is not true in case of existence of negative weight, and thus for graphs with negative weights Dijkstra’s algorithm can return higher distance than than the real minimal one, i.e. wrong result. This is illustrated on the graph in Figure [[#fig:exa_graph_neg_weight|11]].

<div id="fig:exa_graph_neg_weight" class="figure">

[[File:./figs/exa_graph_neg_weight]]

</div>
For this graph Dijkstra’s algorithm would give minimum distance for node <math display="inline">2</math> and <math display="inline">4</math> the value <math display="inline">4</math> and <math display="inline">6</math>, which is wrong, since the right value is <math display="inline">3</math> and <math display="inline">5</math>, respectively

Graph Theory and Algorithms

2025-03-04T22:36:34Z

SAFFER Zsolt: Die Seite wurde neu angelegt: „ = Graph Theory and Algorithms = For a comprehensive subject on graph theory the reader is referred to the book [Gross and Yellen(1998)]. == Seven Bridges of Königsberg == Seven Bridges of Königsberg is a problem of mathematics formulated by Leonhard Euler after a walk in Königsberg in Prussia (now Kaliningrad, Russia). The islands were connected to each ot…“

= Graph Theory and Algorithms =

For a comprehensive subject on graph theory the reader is referred to the book [Gross and Yellen(1998)].


== Seven Bridges of Königsberg ==

Seven Bridges of Königsberg is a problem of mathematics formulated by Leonhard Euler after a walk in Königsberg in Prussia (now Kaliningrad, Russia). The islands were connected to each other and the mainlands on the two sides of the Pregel River via seven bridges (see Figure [[#fig:Königsberg_bridges|2]]).

<div id="fig:Königsberg_bridges" class="figure">

[[File:./figs/Konigsberg_bridges.png]]

</div>
The problem is to find a walk path that would cross each of the seven bridges only once.

Leonhard Euler has resolved the problem in 1736 by showing that such a walk path does not exist. His solution founded the graph theory and therefore the Seven Bridges of Königsberg problem is considered to be the first problem of graph theory.


== Graphs theory basics ==

A graph is a mathematical object consisting of vertices (nodes) and edges connecting pairs of vertices, see example in Figure [[#fig:exa_undirected_graph|3]].

<div id="fig:exa_undirected_graph" class="figure">

[[File:./figs/exa_undirected_graph.pdf]]

</div>
Graph theory studies properties of graphs and problems which can be described by means of graphs. Graph theoretical algorithms and results are applied in many areas, like e.g. transport networks, computer science or biology.


=== Basics ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Basic terms'''

A graph is composed of vertices (nodes) and edges connecting pairs of vertices. Vertex and edge are the two basic units of the graph. The set of vertices and edges is denoted by <math display="inline">\mathcal{V}</math> and <math display="inline">\mathcal{E}</math>, respectively. In undirected graph the edges have no direction, they simple connect two vertices. The graph shown in Figure [[#fig:exa_undirected_graph|3]] is an example of an undirected graph.

The degree of a vertex is the number of edges connected to it. A path is an uninterrupted line connecting two vertices over sequence of edges and vertices. For example the path <math display="inline">(1,2,5,6)</math> in Figure [[#fig:exa_undirected_graph|3]] connects the vertices <math display="inline">1</math> and <math display="inline">6</math>. This way a path is specified by an ordered list of all vertices locating on the uninterrupted line going from the starting vertex of the path to the end vertex of it. A cycle is a path, whose start vertex and end vertex is the same. For example <math display="inline">(1,2,3,4,1)</math> in Figure [[#fig:exa_undirected_graph|3]] is a cycle. A graph is called connected graph, if there is a path between any two vertices of the graph. For example the graph in Figure [[#fig:exa_undirected_graph|3]] is a connected graph.

In the weighted graph each edge has a weight (or cost) associated to them. This weight can represent different physical properties, like e.g. distance between two nodes, capacity of a network link, transport cost of a way between two nodes, etc. An example of a weighted graph can be seen in Figure [[#fig:exa_weighted_graph|4]].

<div id="fig:exa_weighted_graph" class="figure">

[[File:./figs/exa_weighted_graph.pdf]]

</div>
'''<math display="inline">\mathrm{\ \ \ \ }</math> Types of graphs'''

The classification of graphs into various types is based on the properties of the considered subclass of graphs. The most important types of graphs together with their definitions are given as follows.

* Undirected graph - A graph with edges having no direction.
* Directed graph - A graph with edges having direction.
* Unweighted graph - A graph with edges having no weights associated to them.
* Weighted graph - A graph with edges having weights associated to them.
* Connected graph - A graph having path between any two of its vertices.
* Disconnected graph - A graph containing at least one pair of vertices having no path between them.
* Cyclic graph - A graph containing at least one cycle.
* Acyclic graph - A graph does not containing any cycles.
* Tree - A connected acyclic graph.
* Multi-graph - A graph containing at least one pair of vertices having multiple edges between them.
* Simple graph - A graph without cycles and multiple edges between the same pair of vertices.
* Complete graph - A graph in which each pair of vertices is connected by edge.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Graph descriptions'''

The most often used graph representations in algorithms are

* adjacency matrix and
* adjacency list,

because they enable the mathematical description of graphs by means of programming variables, like matrix, array and list.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Adjacency matrix'''''

Adjacency matrix is suitable to describe unweighted graphs, both undirected and directed ones. Adjacency matrix is a <math display="inline">V \times V</math> matrix, whose <math display="inline">(i,j)</math>-th element describes the existence of the connection from vertex <math display="inline">i</math> to vertex <math display="inline">j</math> as a binary value. If there is a connection then this value equals <math display="inline">1</math>, otherwise <math display="inline">0</math>. For example the adjacency matrix of the undirected, unweighted graph example in Figure [[#fig:exa_undirected_graph|3]] looks like

<math display="block">\begin{aligned}
\left(
\begin{array}{llllll}
0 & 1 & 0 & 1 & 0 & 0\\
1 & 0 & 1 & 0 & 1 & 0\\
0 & 1 & 0 & 1 & 0 & 0\\
1 & 0 & 1 & 0 & 1 & 0\\
0 & 1 & 0 & 1 & 0 & 1\\
0 & 0 & 0 & 0 & 1 & 0
\end{array}
\right).
\end{aligned}</math>

The construction of the adjacency matrix implies that the adjacency matrix of an undirected graph is always a symmetric matrix. The idea of describing an unweighted graph by constructing an adjacency matrix as 2-dimensional array can be theoretically extended to describe a weighted graph by constructing a 3-dimensional array, in which the third dimension represents the weight assigned to the edge specified by the first two dimensions. Such a 3-dimensional could be called as adjacency tensor.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Adjacency list'''''

Another way of mathematical representation of a graph is the adjacency list. Adjacency list is an array of lists, in which each list specifies a set of neighbours of a vertex assigned to the actual list as index of the array. In describing a weighted graph, the list consists of the comma separated sequence of "ending vertex: weight" pairs, where each such pair specifies an edge to the given ending vertex with the given weight starting from the vertex to which the considered list belongs to. In case of an unweighted graph the list is a comma separated sequence of neighbour vertexes of the vertex to which the considered list belongs to. Therefore this type of representation is suitable to describe both unweighted and weighted graphs. For example the adjacency list of the unweighted graph example in Figure [[#fig:exa_undirected_graph|3]] is given as

<math display="block">\begin{aligned}
\begin{array}{ll}
1: & \{2,4\} \\
2: & \{1,3,5\}\\
3: & \{2,4\} \\
4: & \{1,3,5\} \\
5: & \{2,4,6\} \\
6: & \{5\}
\end{array}.
\end{aligned}</math>

Similarly the adjacency list of the weighted graph example in Figure [[#fig:exa_weighted_graph|4]] can be given as

<math display="block">\begin{aligned}
\begin{array}{ll}
1: & \{2:5,3:2\} \\
2: & \{1:5,3:3,4:4\}\\
3: & \{1:2,2:3,4:1\} \\
4: & \{2:4,3:1,5:3\} \\
5: & \{1:8,4:3\}
\end{array}.
\end{aligned}</math>

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Edge list'''''

Still another way of mathematically describing a graph is to specify it as edge list. Each edge is specified by a sequence in the form <math display="inline">[</math> starting vertex, ending vertex, weight (optional) <math display="inline">]</math>. Thus the edge list can be given as a two/three column matrix for unweighted/weighted graphs. Hence this type of representation is suitable to describe both unweighted and weighted graphs. The unweighted graph in Figure [[#fig:exa_undirected_graph|3]] and the weighted graph in Figure [[#fig:exa_weighted_graph|4]] can be described by edge list, respectively, as

<math display="block">\begin{aligned}
&&[ [1,2], [2,3], [1,4], [4,5], [2,5], [3,4], [5,6] ] \\
&&[ [1,2,5], [2,3,3], [3,1,2], [2,4,4], [4,3,1], [1,5,8], [4,5,3] ].
\end{aligned}</math>


=== Graph problems ===

Graph theory can be applied for solving different problems in many areas. Without claim for completeness we list several well-known graph problems with their brief description.

* Graph coloring - Graph coloring is a group of problems all of them having something to do with coloring of graphs. Usually they are specified by means of a restriction on the way of coloring, like e.g no adjacent vertices may have the same color. One of the famous result in graph coloring is the so called [https://en.wikipedia.org/wiki/Four_color_theorem Four-color theorem]
* Network flow problems - Network flow problems deal with question related to [https://en.wikipedia.org/wiki/Flow_network Flow networks].
* Covering problems - Covering problems are set cover problems dealing with covering some subsets of vertices/subgraphs. Vertex cover problem is a special case of set cover problems, in which for every edge its starting or end vertex is in the vertex cover.
* Route problems - Route problems are graph problems, which are all related to find a route specified by various constraints on the graph.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Route problems''' 
Route problems form an important class of graph problems, since they have applications in many areas. Here is a list of several selected Route problems, which will be discussed in more details in the rest of this section.

# Hamiltonian path and Eulerian path
# Traveling salesman problem
# Chinese postman problem (Route inspection problem)
# Minimum spanning tree
# Shortest path problem


== Minimum Vertex Cover Problem ==

Vertex cover problem is a kind of set cover problems, in which a set of vertices are searched, which includes at least one endpoint of every edge of the graph. The Minimum Vertex Cover Problem (MIN-VC) is a vertex cover problem on undirected graph, in which a set of minimum number of vertices are searched, which includes at least one endpoint of every edge of the graph.

<div id="fig:exa_graph_minvc" class="figure">

[[File:./figs/exa_graph_minvc.pdf]]

</div>
For example the minimum vertex cover of the example graph in Figure [[#fig:exa_graph_minvc|5]] is <math display="inline">\{2,3,4\}</math> or <math display="inline">\{2,3,5\}</math> or <math display="inline">\{2,4,5\}</math> or <math display="inline">\{1,3,5\}</math>.

The MIN-VC is an optimization problem and it can be reformulated to a decision problem, which is also called as "vertex cover problem". It is known to be [https://en.wikipedia.org/wiki/NP-completeness NP-complete] (nondeterministic polynomial-time complete), so usually so it cannot be solved by a polynomial-time algorithm.

There is an approximate algorithm for determining the minimum vertex cover of an undirected graph. Its schematic representation is shown in Algorithm 1.

 
Algorithm 1 Approximate algorithm for MIN-VC 
'''—————————————————————————————''' 
Input: Undirected graph given by an edge list (= set <math display="inline">\mathcal{E}</math>). 
Output : Found set of vertex cover <math display="inline">\mathcal{C}</math>. 
'''—————————————————————————————''' 
1 Initialise set of vertex cover: <math display="inline">\mathcal{C}</math>=<math display="inline">\{\}</math> 
2 while <math display="inline">\mathcal{E}</math> is not empty 
3 Take an arbitrary edge <math display="inline">(u,v)</math> from set <math display="inline">\mathcal{E}</math> 
4 Add <math display="inline">u</math> and <math display="inline">v</math> to <math display="inline">\mathcal{C}</math> 
5 Remove all edges from set <math display="inline">\mathcal{E}</math> having endpoint either <math display="inline">u</math> or <math display="inline">v</math> 
6 end 
'''—————————————————————————————''' 

It can be proven that the above approximate algorithm for MIN-VC always finds a vertex cover whose size is not more than twice of the size of the minimum vertex cover. The computational complexity of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|+|\mathcal{E}|)</math>. The memory need of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|</math> The memory is needed to store the visited vertices, i.e. the set <math display="inline">\mathcal{C}</math>.


== Eulerian path and Hamiltonian path ==


=== Eulerian path and cycle ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Eulerian path'''

Eulerian path in an undirected graph <math display="inline">\boldsymbol{G}</math> is a path that visits every edges of <math display="inline">\boldsymbol{G}</math> exactly once. Note that the undirected graph <math display="inline">\boldsymbol{G}</math> can be unweighted or weighted. However this does not affect the mathematical treatment of Eulerian path, therefore we treat these cases commonly by simple omitting unweighted or weighted characterization of <math display="inline">\boldsymbol{G}</math>.

The necessary and sufficient conditions for for the existence of Eulerian path in the undirected graph <math display="inline">\boldsymbol{G}</math> can be given as

* Every vertices with non-zero degree of <math display="inline">\boldsymbol{G}</math> form a connected graph.
* Either none of the vertices or exactly two vertices of <math display="inline">\boldsymbol{G}</math> have odd degree and all its other vertices have even degree.

Along the Euler path, each time walking through a vertex we walking through two previously unseen edges: one at approaching the vertex and the other at leaving it. On this way the number of edges at each middle vertex (i.e. the vertices except the starting and ending vertices of the path) must be even. The starting and ending vertices of the path are enabled to have odd degree, as the start or finish of the walk goes through on only one edge connected to that vertices. This argument proves the necessity of the condition. It turns out that the condition is also sufficient.

<div id="fig:exa_graph_E-path" class="figure">

[[File:./figs/exa_graph_E-path.pdf]]

</div>
For example the example graph in Figure [[#fig:exa_graph_E-path|6]] has an Euler path <math display="inline">(1,3,4,5,2,4)</math>, since only vertices <math display="inline">1</math> and <math display="inline">4</math> have odd degree.

An Euler path can be determined by going through the graph starting from a vertex with odd degree and selecting always previously unseen edges at each vertices. The conditions ensure that this always leads to an Euler path. This process requires the logging of the already visited edges at each vertex. It follows that the computational complexity of finding an Euler path is <math display="inline">\mathcal{O}(|\mathcal{V}|^2</math>

The Seven Bridges of Königsberg is a problem of finding an Euler path. In fact Leonard Euler solved it in 1736 by showing that there is no path that visits every of the seven bridges exactly once. His solution applies the above argument for necessary condition. Euler’s solution of the Königsberg bridge problem is the first theorem of graph theory and laid the foundations of graph theory.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Eulerian cycle'''

Eulerian cycle in an undirected graph <math display="inline">\boldsymbol{G}</math> is a closed path that visits every edges of <math display="inline">\boldsymbol{G}</math> exactly once and returns to the starting vertex. Similarly to Eulerian path, the undirected graph <math display="inline">\boldsymbol{G}</math> can be unweighted or weighted, which does not affect of the mathematical treatment of Eulerian cycle. Hence these cases are treated commonly by simple omitting unweighted or weighted characterization of <math display="inline">\boldsymbol{G}</math>. A graph containing a Eulerian cycle is a Eulerian graph.

The necessary and sufficient conditions for the existence of Eulerian cycle in the undirected graph <math display="inline">\boldsymbol{G}</math> can be formulated as

* Every vertices with non-zero degree of <math display="inline">\boldsymbol{G}</math> form a connected graph.
* Every vertices of <math display="inline">\boldsymbol{G}</math> have even degree.

This can be argumented similarly as in case of Eulerian path. Because in case of Eulerian cycle the path returns to the starting vertex, no odd degree is allowed yet for that vertex.

The example graph in Figure [[#fig:exa_graph_E-path|6]] has no Eulerian cycle, since not every vertices have even degree (vertices <math display="inline">1</math> and <math display="inline">4</math> have odd degree).

<div id="fig:exa_graph_E-cycle" class="figure">

[[File:./figs/exa_graph_E-cycle.pdf]]

</div>
However the in the graph in Figure [[#fig:exa_graph_E-cycle|7]] every vertices have even degree, therefore it has a Eulerian cycle, e.g. (1,3,5,6,7,5,4,3,2,1).

Finding a Eulerian cycle can be completed on the same way as described for Eulerian path, but the visit can start at any vertex, since all vertices have even degree. Like in case of finding an Eulerian path, finding a Eulerian cycle has a computational complexity of <math display="inline">\mathcal{O}(|\mathcal{V}|^2</math>.


=== Hamiltonian path and cycle ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Hamiltonian path'''

Hamiltonian path in an undirected graph <math display="inline">\boldsymbol{G}</math> is a path that goes through every vertex of <math display="inline">\boldsymbol{G}</math> exactly once. The path have not to return to the starting vertex, i.e. Hamiltonian path is an open path. Finding a Hamiltonian path is in general an NP-complete problem.

For example the example graph in Figure [[#fig:exa_undirected_graph|3]] has more Hamiltonian paths: <math display="inline">(3,2,1,4,5,6)</math> or <math display="inline">(1,4,3,2,5,6)</math>.

Hamiltonian path has applications in many fields including

* transportation networks (finding optimal routes),
* circuit design and
* graph theory research.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Hamiltonian cycle'''

Hamiltonian cycle (or Hamiltonian circuit) in an undirected graph <math display="inline">\boldsymbol{G}</math> is a closed path that goes through every vertex of <math display="inline">\boldsymbol{G}</math> exactly once and returns to the starting vertex. A graph containing a Hamiltonian cycle is a Hamiltonian graph, otherwise it is non-Hamiltonian graph. Like in case of finding a Hamiltonian path, finding a Hamiltonian cycle is also an NP-complete problem. Finding a Hamiltonian path is often easier than finding a Hamiltonian cycle.

The example graph in Figure [[#fig:exa_undirected_graph|3]] has no Hamiltonian cycle.

<div id="fig:exa_graph_H_cycle" class="figure">

[[File:./figs/exa_graph_H_cycle.pdf]]

</div>
However a slightly different graph in Figure [[#fig:exa_graph_H_cycle|8]] has a Hamiltonian cycle: (5,2,1,4,3,5).

Hamiltonian cycle has applications in many fields including

* computer science,
* logistics and
* network design.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Algorithms for finding Hamiltonian cycle'''

In the next we give a brief description of the following two algorithms for finding Hamiltonian cycle:

* Brute-force search and
* Backtracing algorithm

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Brute-force search - for finding Hamiltonian cycle'''''

The brute-force search (also called exhaustive search) follows a naive approach and tries all the possible permutations of all the <math display="inline">|V|</math> vertices. This results in <math display="inline">|V|!</math> different sequences of the <math display="inline">|V|</math> vertices, so the computational complexity of this algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|!)</math>.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Backtracing algorithm - for finding Hamiltonian cycle'''''

The idea of Backtracing algorithm is to add iteratively a new vertex to the actual path of subsequence of vertices, which is an adjacent to the last vertex of the actual path and not yet included in that path. After having the path with <math display="inline">|\mathcal{V}|</math> vertices, it is checked whether it composes a cycle or not. If not then change the path by trying systematically all the adjacent vertices at every position in the path backwards, which is called backtracking.

The algorithm can be implemented on elegant way by applying a recursive function call. The pseudo code of the algorithm is given in Algorithm 2.

 
Algorithm 2 Backtracing algorithm - for finding Hamiltonian cycle 
'''—————————————————————————————''' 
Input: Undirected graph. 
Output: 
- true, if Hamiltonian cycle found, 
- false, if Hamiltonian cycle exist 
'''—————————————————————————————''' 
1 Initialise path (=sequence of <math display="inline">|\mathcal{V}|</math> vertices) 
2 Set <math display="inline">path[0]</math>= first vertex 
3 if <math display="inline">try\_next\_vertex\_and\_check\_cycle(1)</math> 
4 return <math display="inline">true</math> (cycle found) 
5 else 
6 return <math display="inline">false</math> (cycle not exists) 
7 end 
'''—————————————————————————————''' 
Recursive function 
bool try_next_vertex_and_check_cycle(path_index k) 
Input: next index in the path (=sequence of <math display="inline">|\mathcal{V}|</math> vertices) 
Output: 
- true, if cycle found, 
- false, if backtracking or cycle not exists 
'''—————————————————————————————''' 
1 if <math display="inline">k == |\mathcal{V}|</math> 
2 if exists edge between last and first vertices of path 
3 return <math display="inline">true</math> (cycle found) 
4 else 
5 return <math display="inline">false</math> (backtracking or cycle not exists) 
6 end 
7 for <math display="inline">v \in \mathcal{V}</math> 
8 if <math display="inline">v</math> is adjacent to <math display="inline">path[k-1]</math> (=last vertex in path) 
9 and 
10 <math display="inline">v</math> is not yet in <math display="inline">path[]</math> 
11 path[k]=v 
12 if <math display="inline">try\_next\_vertex\_and\_check\_cycle(k+1)</math> 
13 return <math display="inline">true</math> 
14 end 
15 (Backtracking - remove v from path) 
16 <math display="inline">path[k] = -1</math> 
17 end 
18 end 
19 return false (backtracking or cycle not exists) 
'''—————————————————————————————''' 

In the course of backtracking every neighbours of every vertices can be tried by the algorithm. Therefore its computational complexity is <math display="inline">\mathcal{O}(|\mathcal{V}|!)</math>.


== Chinese postman problem (Route inspection problem) ==

The Chinese postman problem (also called as route inspection problem) is an extension of finding Eulerian cycle in connected and (unweighted or weighted) undirected graphs. The Chinese postman problem is to find shortest path that visits every edge of the connected and undirected graph <math display="inline">\boldsymbol{G}</math> at least once and return to the starting vertex. So the problem is defined on connected graph. The shortest path is defined as the one with minimum number of edges for unweighted graph and as the path with minimum accumulated weights for weighted graph. The solution path of Chinese postman problem is called Chinese postman tour. The Chinese postman problem can be solved in polynomial time.


=== Solution for Eulerian graph ===

If the graph <math display="inline">\boldsymbol{G}</math> contains an Eulerian cycle, then it is also the solution for the Chinese postman problem, since Eulerian cycle has the shortest path (minimum number of edges in unweighted graph and minimum accumulated weights in weighted graph) due to the necessity of visiting all edges at least once.

Therefore the necessary and sufficient condition for the solution for the Chinese postman problem to be the Eulerian cycle is the existence of Eulerian cycle, which can be given as

* Every vertices of <math display="inline">\boldsymbol{G}</math> have even degree.

For example graph in Figure [[#fig:exa_graph_E-cycle|7]] the solution, i.e the Chinese postman tour is the Eulerian cycle, e.g. (1,3,5,6,7,5,4,3,2,1).


=== Solution for Non-Eulerian graph ===

If the graph <math display="inline">\boldsymbol{G}</math> has no Eulerian cycle, then the graph must be extended to become Eulerian. This is done by duplicating some edges of <math display="inline">\boldsymbol{G}</math> connected to vertices with odd degree in order to change the degree of all these vertices become to even. The edges to be duplicated must be selected from the relevant ones (i.e. connected to vertices with odd degree) on that way, that the increase of the path length due to edge duplication must be the possible smallest. Therefore those pairing of the vertices with odd degree are selected, which have the shortest path connecting them.

The example unweighted graph in Figure [[#fig:exa_graph_cpp_unweighted|9]] shows a Non-Eulerian graph and the Chinese postman tour obtained by duplicating the edges [2,4] and [3,1].

<div id="fig:exa_graph_cpp_unweighted" class="figure">

[[File:./figs/exa_graph_cpp_unweighted.pdf]]

</div>
Similarly the example Non-Eulerian weighted graph in Figure [[#fig:exa_graph_cpp_weighted|10]] illustrates the construction of the Chinese postman by duplicating the edges [2,4], [4,6] and [5,1]. Here duplicating [2,4] together with [4,6] instead of [2,6] inserts shorter path (i.e. accumulated weight 2+1= 3 instead of 5). Similarly duplicating [5,1] instead of [5,3] together with [3,1] inserts shorter path (i.e. accumulated weight 1 instead of 1+2=3).

<div id="fig:exa_graph_cpp_weighted" class="figure">

[[File:./figs/exa_graph_cpp_weighted.pdf]]

</div>

=== Algorithm for Chinese postman problem ===

Based on the above considerations the algorithm for finding the Chinese postman route can be given schematically by means of its steps in Algorithm 3.

 
Algorithm 3 Algorithm for Chinese postman problem 
'''—————————————————————————————''' 
Input: Undirected graph <math display="inline">\boldsymbol{G}</math>. 
Output: Chinese postman route. 
'''—————————————————————————————''' 
1 if grap <math display="inline">\boldsymbol{G}</math> is Eulerian 
2 Find an Eulerian cycle in <math display="inline">\boldsymbol{G}</math> 
3 <math display="inline">totalWeight</math> = sum of all edge weights of <math display="inline">\boldsymbol{G}</math> 
4 return Eulerian cycle and <math display="inline">totalWeight</math> 
5 else 
6 Determine <math display="inline">N</math> from graph, <math display="inline">N =|\mathcal{V}|</math> 
7 Find all vertices with odd degree and store in array <math display="inline">oddVertices</math> 
8 Construct the complete graph <math display="inline">\boldsymbol{C}</math> from odd vertices together with edges 
<math display="inline">\mathrm{\ \ \ \ \ }</math>representing shortest paths among any pairs of odd vertices 
9 Find minimum weight perfect matching in <math display="inline">\boldsymbol{C}</math>, i.e the set of edges 
<math display="inline">\mathrm{\ \ \ \ \ }</math> reaching every odd vertices and together having smallest sum of weights. 
<math display="inline">\mathrm{\ \ \ \ \ }</math> This set of edges is called minimum T-join. 
10 Extend the graph <math display="inline">\boldsymbol{G}</math> by adding all edges from minimum T-join 
<math display="inline">\mathrm{\ \ \ \ \ }</math> resulting in extended graph <math display="inline">\boldsymbol{H}</math> 
12 Find an Eulerian cycle in <math display="inline">\boldsymbol{H}</math> 
13 <math display="inline">totalWeight</math> = sum of all edge weights of <math display="inline">\boldsymbol{H}</math> 
14 return Eulerian cycle of <math display="inline">\boldsymbol{H}</math> and <math display="inline">totalWeight</math> 
15 end 
'''—————————————————————————————''' 

The numerical complexity of the above minimum T-join based algorithm for solving the Chinese postman problem is <math display="inline">\mathcal{O}(|\mathcal{V}|^3)</math>, since both setting up the complete graph, and finding minimum weight perfect matching in it takes <math display="inline">\mathcal{O}(|\mathcal{V}|^3)</math> computational steps.


== Minimum spanning tree - Kruskal’s algorithm ==

A spanning tree of a graph is a tree including every vertices of the graph. The number of edges of a spanning tree is <math display="inline">|\mathcal{V}|-1</math>, since the <math display="inline">|\mathcal{V}|</math>-th edge would introduce a cycle and it were not any more a tree.

The minimum spanning tree (MST) is defined for a weighted, undirected, connected graph <math display="inline">\boldsymbol{G}</math>, as a spanning tree with the minimal accumulated weights.

Kruskal’s algorithm can be used to determine the MST of graph <math display="inline">\boldsymbol{G}</math>. In the Kruskal’s algorithm all edges of <math display="inline">\boldsymbol{G}</math> are sorted according to their weights in increasing order. Then the algorithm iteratively adds the next edge from the sorted list, i.e. the edge with the smallest weight, together with their vertexes to MST, if the newly added edge does not induce a cycle. The algorithm proceeds until every edge on the list is checked. On this way the resulted graph will have <math display="inline">|\mathcal{V}|-1</math> edge, so it will be a spanning tree and the way of constructing implies that it will have the least accumulated weights.

The algorithm takes in each step the locally optimal decision due to adding the edge with the smallest weight among the still available ones. Therefore Kruskal’s algorithm is a greedy algorithm.

The algorithm is shown schematically in Algorithm 4.

 
Algorithm 4 Kruskal’s algorithm for detrmining MST 
'''—————————————————————————————''' 
Input: Undirected weighted connected graph <math display="inline">\boldsymbol{G}</math>. 
Output: MST of <math display="inline">\boldsymbol{G}</math>. 
'''—————————————————————————————''' 
1 Initialise graph MST to be set empty. 
2 Sort every edges of <math display="inline">\boldsymbol{G}</math> in increasing weight order and insert them, 
<math display="inline">\mathrm{\ \ }</math> together with their vertexes into array <math display="inline">sortedListEdges[]</math> 
3 for <math display="inline">v=0,\ldots size(sortedListEdges)-1</math> 
4 if inserting <math display="inline">sortedListEdges[v]</math> into MST does not induce a cycle 
5 Add <math display="inline">sortedListEdges[v]</math> into MST 
6 end 
7 end 
8 return MST 
'''—————————————————————————————''' 

The computational complexity of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{E}|))</math>, since sorting the edges has <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{E}|))</math> complexity, iterating through every edges and checking cycle has <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{V}|))</math> and <math display="inline">\mathcal{O}(log(|\mathcal{V}|) =\mathcal{O}(log(|\mathcal{E}|)</math> due to <math display="inline">|\mathcal{E}|</math> is at most <math display="inline">|\mathcal{V}|^2</math>.

The memory need of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|+|\mathcal{E}|)</math>, which is needed to store edges together with their vertexes.


== Traveling salesman problem ==

The Traveling Salesman Problem (TSP) originates from a context of cities and given distances among them. TSP is to look for the shortest path that goes through each city exactly once and returns to the starting city. Usually there exists a route between any pair of cities with some given distance. In graph theory context an equivalent formulation of TSP can be given as looking for a path with the least accumulated weights in a weighted, often complete graph, that goes through each vertex exactly once and returns to the starting vertex. This is equivalent with finding the Hamiltonian cycle with the minimum accumulated weight in a weighted, often complete graph. Thus the TSP is more general than Hamilton cycle problem and hence Hamilton cycle problem is a special case of TSP. The resulted path can be also called as TSP path.

The TSP was formulated mathematically in the 19th century and was first studied mathematically in the 1930s. The decision problem version of TSP is an NP-complete problem, so TSP is NP-hard. TSP is one of the most intensively investigated problem in combinatorial optimization, since it is used as benchmark for other optimization methods in terms of computational complexity.

Some properties of TSP can be provided as

* Symmetric and asymmetric TSP. In symmetric TSP the distance between two cities is the same in both direction, which leads to a formulation in graph theory context to a TSP on undirected graph. In asymmetric TSP either do not exist a path between two cities in both direction or the distances are different excluding the higher one from the TSP formulation. In these cases the formulation in graph theory context yileds a TSP on directed graph.
* Completing the graph by adding edges with sufficiently long distances will not affect the optimal path.
* The path to be a cycle or an open path does not make difference in the computational complexity of TSP (like in case of Hamilton path problem).

The TSP has applications in numerous fields, like logistics, route planning in transport networks, manufacturing of microchips and DNA sequencing. One-way streets, airfares with different departure and arrival fees are real-world scenarios for applying asymmetric TSP.


=== Generalizations of TSP ===

Several generalizations of TSP are listed below.

* The travelling politician problem (also called as "generalized travelling salesman problem") has a context with states having one or more cities and the travelling man must visit exactly one city from each state. It has been shown that travelling politician problem can be led back to standard TSP with modified distance matrix.
* The travelling purchaser problem has a purchaser, who has to buy a set of products, which can be bought in more cities but at different prices. The optimization objective is to find a path among a subset of cities that enables to buy all the products with minimal total cost (=taveling cost + purchasing cost).
* Vehicle routing problem.
* Ring star problem ([Labbé et al.(2004)]).


=== Integer linear programming formulation ===

In order to form the TSP as Integer Linear Programming (ILP) optimization, several variables must be introduced. Let <math display="inline">N</math> denote the number of cities (vertices), i.e. <math display="inline">N = |\mathcal{V}|</math>. Let <math display="inline">c_{ij}</math> stand for the distances (weights) between the cities (vertices) <math display="inline">i</math> and <math display="inline">j</math>, for <math display="inline">i,j = 1, \ldots, N</math>. Let <math display="inline">x_{ij}</math> be a decision variable describing whether the path goes from city (vertix) <math display="inline">i</math> to <math display="inline">j</math>, or not for <math display="inline">i,j = 1, \ldots, N</math>. In other words <math display="block">x_{ij} = \left\{
\begin{aligned}
1, \mathrm{\ \ } \mathrm{~if~path~goes~i \rightarrow j} \\
0, \mathrm{\ \ } \mathrm{~otherwise~~~~~~~~~~~}
\end{aligned}
\right\}.</math> The integer nature of the values <math display="inline">0</math> and <math display="inline">1</math> makes this optimization problem an ILP. The objective function of the optimization task is to minimize the path length (= accumulated weights), in other word

<math display="block">\arg \min_{x_{ij}} \sum_{i=1}^{N} \sum_{j=1,~j \neq i}^{N} c_{ij} x_{ij} ~j = 1, \ldots, N.</math>

However without further constraints this optimization considers not only paths, which are characterized by also leaving each reached vertex, but all set of edges enabling the minimum being at <math display="inline">x_{ij}=0</math> for every <math display="inline">i,j \in \mathcal{V}</math>. Therefore further constraints are necessary to ensure that paths are considered and each vertex is visited exactly once. These requirements can be forced by formulating the following further two constraints, which force that the path reaches each vertex exactly once and leaves each vertex exactly once <math display="block">\begin{aligned}
\sum_{i=1,~i \neq j}^{N} x_{ij} = 1, ~~ j = 1, \ldots, N, \\
\sum_{j=1,~j \neq i}^{N} x_{ij} = 1, ~~ i = 1, \ldots, N.
\end{aligned}</math>

These constraints ensure that the selected way looks locally as path and all vertices are visited, but still allow that the selected set of edges comprises several local paths each of them visiting only a disjunct subset of vertices instead of one global path visiting every vertices. This global path requirement makes TSP a difficult problem. There are more ways to formulate this global path requirement as a linear constraint. The Miller-Tucker-Zemlin formulation introduces dummy variables <math display="inline">u_i</math> for keeping track the order of visit the city <math display="inline">i</math>, for <math display="inline">i = 1, \ldots, N</math>. The path starts with visiting city <math display="inline">1</math>. The global path requirement is ensured by forcing <math display="inline">u_j</math> being higher than <math display="inline">u_i</math> when city <math display="inline">i</math> is visited before city <math display="inline">j</math>, for <math display="inline">i = 2, \ldots, N</math>. More precisely <math display="inline">u_j</math> must be higher than <math display="inline">u_i</math> at least by one when city <math display="inline">j</math> locates on the path after city <math display="inline">i</math>, and otherwise by a values less than <math display="inline">N</math> to ensure that <math display="inline">x_{ij}=0</math> does not force an unwanted relation between <math display="inline">u_i</math> and <math display="inline">u_j</math>. Since city <math display="inline">1</math> is left out from these constraint, it ensures that the optimal path must return to city <math display="inline">1</math>, otherwise the value of the dummy variable of the city visited after city <math display="inline">N-1</math> would be less that <math display="inline">u_{N-1}</math>, which would violate the constraint. The city <math display="inline">1</math> is the only one for which a decrease in value of the dummy variable allowed when the path reaches city <math display="inline">1</math>. These considerations lead to the formulation of the global path requirement as a linear constraint as <math display="block">u_i -u_j + 1 \leq (N-1)(1-x_{ij}) ~~ i,j \in \{2, \ldots, N \} \mathrm{~and~} i \leq j.</math>

Putting all these together gives the Miller-Tucker-Zemlin ILP formulation of the TSP as <math display="block">\begin{aligned}
\arg \min_{x_{ij}} \sum_{i=1}^{N} \sum_{j=1,~j \neq i}^{N} c_{ij} x_{ij},~\ldots, N, ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~subject~to} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~constraint~}1.~~~ \sum_{i=1,~i \neq j}^{N} x_{ij} = 1, ~~ j = 1, \ldots, N, ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~constraint~}2.~~~ \sum_{j=1,~j \neq i}^{N} x_{ij} = 1, ~~ i = 1, \ldots, N, \mathrm{~and~} ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\\
\mathrm{~constraint~}3.~~~ u_i -u_j + 1 \leq (N-1)(1-x_{ij}) ~~ i,j \in \{2, \ldots, N \} \mathrm{~and~} i \leq j.
\end{aligned}</math>


=== Algorithms for TSP ===

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Exact algorithm - Brute-force search'''''

The brute-force search tries all the possible permutations of all the <math display="inline">|V|</math> vertices and selects the one with the lowest accumulated weights. This results in <math display="inline">|V|!</math> different sequence of vertices the <math display="inline">|V|</math> vertices, so the computational complexity of this algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|!)</math>. Hence this approach becomes intractable already for number of cities in the magnitude of <math display="inline">20</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Approximate algorithms'''

Due to the NP-completeness of the TSP the exact solution becomes intractable very fast as the number of cities increases. Therefore there is a need for establishing approximate algorithms for the TSP.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Nearest neighbour algorithm'''''

The Nearest Neighbour (NN) algorithm selects the nearest not yet visited neighbour city at each step. Thus its decision is locally optimal in each step, therefore it is a greedy algorithm. Its schematic representation is shown in Algorithm 5.

 
Algorithm 5 Nearest neighbour approximate algorithm for TSP 
'''—————————————————————————————''' 
Input: Undirected weighted graph. 
Output: Hamiltonian cycle with minimum accumulated weights. 
'''—————————————————————————————''' 
1 Determine <math display="inline">N</math> from graph, <math display="inline">N =|\mathcal{V}|</math> 
2 Initialize <math display="inline">path</math> array, set <math display="inline">path[0]=1</math> and set <math display="inline">totalWeight = 0</math> 
<math display="inline">\mathrm{\ \ }</math> (<math display="inline">path</math> array =sequence of <math display="inline">N</math> vertices) 
3 for <math display="inline">v=1,\ldots N-1</math> 
4 Select nearest not yet visited city among neighbours of city <math display="inline">path[v-1]</math>, <math display="inline">u</math> 
5 <math display="inline">path[v]=u</math> 
6 <math display="inline">totalWeight += weight(path[v-1], u)</math> 
7 end 
8 return <math display="inline">path</math>, <math display="inline">totalWeight</math> 
'''—————————————————————————————''' 

The computational complexity of the NN algorithm is <math display="inline">\mathcal{O}(|\mathcal{V}|)</math>. For city arrangement distributed randomly on the plane, the NN algorithms gives a path which is only 25% longer than the shortest one. However for specific city arrangements the NN algorithm can produce also the worst route.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Christofides algorithm'''''

The heuristic approach of Christofides is based on using graph theoretical results to compose an approximate algorithm. It utilizes that a TSP path can not be longer than an Eulerian path over all cities of the graph. Therefore first a subgraph including all cities must be found, than it is extended to be an Eulerian graph, afterwards the Eulerian path is determined in the Eulerian graph and finally it is converted to a TSP path (i.e. to visit each city only once). If the minimum spanning tree of the original graph is selected as first graph and it is made to be an Eulerian graph by doubling every edge in it, then the total length of an Eulerian path can not be more than twice the one of the TSP path. Note that the length of the path changes also at converting the Eulerian path to a TSP path. During this step, shortcut is created for each city visited twice by inserting an edge from the city before this to a city after this. On this way one can approximate a solution for the TSP. The steps of the Christofides algorithm are shown schematically in Algorithm 6.

 
Algorithm 6 Christofides approximate algorithm for TSP 
'''—————————————————————————————''' 
Input: Undirected weighted graph. 
Output: Approximate TSP path. 
'''—————————————————————————————''' 
1 Find a minimum spanning tree <math display="inline">\boldsymbol{T}</math> of the graph. 
2 Duplicate every edges of <math display="inline">\boldsymbol{T}</math> to create an Eulerian graph <math display="inline">\boldsymbol{M}</math> 
3 Find an Eulerian path in <math display="inline">\boldsymbol{M}</math> 
4 Convert Eulerian path to approximate TSP path by using shortcuts 
5 return approximate TSP path 
'''—————————————————————————————''' 

The Christofides algorithm was one of the first approximation algorithm, which shown that establishing an approximation algorithms can be practically usable approach for solving exactly intractable problems.

An improved version of the algorithm is the algorithm of Christofides and Serdyukov, in whic a better way of creating an Eulerian graph is applied. This is done by applying the so called minimum weight matching. The steps of the algorithm of Christofides and Serdyukov can be seen schematically in Algorithm 7.

 
Algorithm 7 Approximate algorithm of Christofides and Serdyukov for TSP 
'''—————————————————————————————''' 
Input: Undirected weighted graph. 
Output: Approximate TSP path. 
'''—————————————————————————————''' 
1 Find a minimum spanning tree <math display="inline">\boldsymbol{T}</math> of the graph. 
2 Apply minimum weight matching to odd-degree vertices of <math display="inline">\boldsymbol{T}</math> giving graph <math display="inline">\boldsymbol{W}</math> 
3 Find optimal Eulerian path in <math display="inline">\boldsymbol{W}</math> 
4 Convert Eulerian path to approximate TSP path by using shortcuts 
5 return approximate TSP path 
'''—————————————————————————————''' 

Approximate algorithm of Christofides and Serdyukov gives an approximate TSP path with accumulated weights, which is at most 1,5 times higher than the one of the optimal TSP path. The computational complexity of the approximate algorithm of Christofides and Serdyukov is <math display="inline">\mathcal{O}(|\mathcal{V}|^3)</math>, which is mainly caused by minimum weight matching algorithm part.


== Shortest path problem ==

The shortest path in a weighted graph between two vertices is the path connecting them with the smallest accumulated weight. There are more algorithm for finding shortest path, each with a slightly different applicability scope.

Besides of Diskstra’s algoritm another common algorithms are the [https://en.wikipedia.org/wiki/Bellman-Ford_algorithm Bellman-Ford] and the [https://en.wikipedia.org/wiki/Floyd-Warshall_algorithm Floyd Warshall] algorithms.


=== Dijkstra-Algorithmus ===

Diskstra’s algorithm finds the shortest path from a given source vertex to every vertices in a weighted graph <math display="inline">\boldsymbol{G}</math>. The graph must not contain negative edge, since in that case the algorithm fails.

The idea of Diskstra’s algorithm is an iterative extension of shortest path tree (SPT) containing a subtree with vertices, for which the shortest paths from the a given source have already been found. The vertices outside of SPT have also minimum distance values assigned during the intermediate steps of the processing. The minimum distance values of vertices being neighbour of any vertices of SPT and locating outside of SPT represent the minimum distance from source vertex to the considered vertex via every possible routes over the vertices of the actual SPT. The iterative extension of SPT is performed by selecting the vertex <math display="inline">u</math> with the shortest minimum distance among the vertices locating outside of SPT, adding this vertex <math display="inline">u</math> together with its minimum distance to SPT and reevaluating the minimum distances of each vertex <math display="inline">v</math> locating outside of the updated SPT and being the neighbour of <math display="inline">u</math>. During the reevaluation the minimum distance of <math display="inline">v</math> is compared to the sum (minimum distance of <math display="inline">v</math> + weight of (<math display="inline">v</math>- <math display="inline">u</math>)) and if the later is smaller then the minimum distance of <math display="inline">v</math> will be updated.

The schematical representation of the algorithm can be seen in Algorithm 8.

 
Algorithm 8 Dijkstra-Algorithmus for determining SPT 
'''—————————————————————————————''' 
Inputs: 
- Undirected weighted connected graph <math display="inline">\boldsymbol{G}</math>. 
- Source vertex <math display="inline">s</math>. 
Output: Array of minimum distances to every vertices <math display="inline">minDist[]</math>. 
'''—————————————————————————————''' 
1 Create an adjacenty matrix <math display="inline">{\bf S}</math> for maintaining SPT with vertices (subtree), 
<math display="inline">\mathrm{\ \ \ }</math>for which the shortest paths from the a given source have already been found 
<math display="inline">\mathrm{\ \ \ }</math>and initialize it to empty. 
<math display="inline">\mathrm{\ \ \ }</math>Matrix <math display="inline">{\bf S}</math> stores already found minimum distance values for its vertices. 
2 Create and adjacency matrix <math display="inline">{\bf A}</math> for representing the graph <math display="inline">\boldsymbol{R}</math> being a 
<math display="inline">\mathrm{\ \ \ }</math>subgraph of <math display="inline">\boldsymbol{G}</math> containing vertices locating outside of SPT 
<math display="inline">\mathrm{\ \ \ }</math>and every edges of them. Matrix <math display="inline">{\bf A}</math> stores also actual values of 
<math display="inline">\mathrm{\ \ \ }</math>minimum distance to every vertices of <math display="inline">\boldsymbol{R}</math>. 
<math display="inline">\mathrm{\ \ \ }</math>Initialize all these distance values to <math display="inline">\infty</math>, and for the source vertex 
<math display="inline">\mathrm{\ \ \ }</math>set the minimum distance to the value <math display="inline">0</math>. 
3 while matrix <math display="inline">{\bf A}</math> is not empty (=not all vertices are moved from it) 
4 take a vertex <math display="inline">u</math> from subgraph matrix <math display="inline">{\bf A}</math> with the smallest minimum distance 
5 add vertex <math display="inline">u</math> with its minimum distance and its edge connecting it to SPT 
6 matrix <math display="inline">{\bf S}</math> 
7 for each vertex <math display="inline">v</math> of graph <math display="inline">\boldsymbol{R}</math> being neighbour of <math display="inline">u</math> 
8 (update minimum distance of vertex <math display="inline">v</math> in matrix <math display="inline">{\bf A}</math>: ) 
9 if minimum distance of <math display="inline">u</math> + weight of (<math display="inline">v</math>- <math display="inline">u</math>) < minimum distance of <math display="inline">v</math> 
10 minimum distance of <math display="inline">v</math> = minimum distance of <math display="inline">u</math> + weight of (<math display="inline">v</math>- <math display="inline">u</math>) 
11 mark edge of <math display="inline">v</math> to <math display="inline">u</math> as edge connecting to SPT 
12 end 
13 end 
14 remove the row of vertex <math display="inline">u</math> from subgraph matrix <math display="inline">{\bf A}</math> 
15 (that means also removing vertex <math display="inline">u</math> from subgraph <math display="inline">\boldsymbol{R}</math>) 
16 end 
17 Build up array <math display="inline">minDist[]</math> from SPT matrix <math display="inline">{\bf S}</math> 
18 return array <math display="inline">minDist[]</math> 
'''—————————————————————————————''' 

The computational complexity of the algorithm is <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{V}|))</math>, since finding the vertex in the subgraph <math display="inline">\boldsymbol{R}</math> takes <math display="inline">\mathcal{O}(log(|\mathcal{V}|))</math> operations, which must be done for every vertices. Note that it is the same as <math display="inline">\mathcal{O}(|\mathcal{E}|*log(|\mathcal{E}|))</math> due to <math display="inline">\mathcal{O}(log(|\mathcal{V}|))= \mathcal{O}(log(|\mathcal{E}|))</math>.

The finding the vertex of subgraph <math display="inline">\boldsymbol{R}</math> with the smallest minimum distance can be implemented by the help of priority queue (or Heap). The standard usage of priority queue would overwrite minimum distance in the inserted pair (minimum distance - vertex) for the same vertex always by the minimum distance of the lastly checked edge to that vertex, which is not necessarily the smallest one among every edges. This can be resolved by inserting more copies of the pair (minimum distance - vertex) for the same vertex, since priority queue will take only the one of them with the smallest value of minimum distance.

Dijkstra’s algorithm assumes that in each intermediate step, the minimum distances of the vertices in SPT, are already the final ones, i.e. the shortest paths from the a given source to the vertices of SPT have already been found. This holds with non- negative weight, since in this case a new path to a vertex in SPT via any vertices of outside of SPT would increase the distance by a sum of non-negative weights which then can not be smaller then the distance marked in SPT as the minimum one. However this is not true in case of existence of negative weight, and thus for graphs with negative weights Dijkstra’s algorithm can return higher distance than than the real minimal one, i.e. wrong result. This is illustrated on the graph in Figure [[#fig:exa_graph_neg_weight|11]].

<div id="fig:exa_graph_neg_weight" class="figure">

[[File:./figs/exa_graph_neg_weight]]

</div>
For this graph Dijkstra’s algorithm would give minimum distance for node <math display="inline">2</math> and <math display="inline">4</math> the value <math display="inline">4</math> and <math display="inline">6</math>, which is wrong, since the right value is <math display="inline">3</math> and <math display="inline">5</math>, respectively

Number Theory

2025-03-04T22:10:31Z

SAFFER Zsolt: Die Seite wurde neu angelegt: „ = Number Theory and its Application to Cryptography, Combinatorics, Relations = For a comprehensive subject on number theory the reader is referred to the book [Hardy and Wright(1975)]. == Elementary number theory == === Prime factorisation === '''<math display="inline">\m…“

= Number Theory and its Application to Cryptography, Combinatorics, Relations =

For a comprehensive subject on number theory the reader is referred to the book [Hardy and Wright(1975)].


== Elementary number theory ==


=== Prime factorisation ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Fundamental theorem of arithmetic'''

 Fundamental theorem of arithmetic - in number theory 
Every integer <math display="inline">a > 1</math> is either prime itself or the product of prime numbers, where this product is unique, up to the order of the factors. In other words

<math display="block">a= \prod_{i=1}^{n} p_i^{e_i}</math>

where <math display="inline">p_i</math> is the <math display="inline">i</math>-th prime number arising in the product generating <math display="inline">a</math> and <math display="inline">e_i</math> is its multiplicity.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Prime factorisation algorithm''' 
The prime factorisation is an iterative algorithm to determine the prime factors of a given number. The algorithm is based on the Fundamental theorem of arithmetic. The prime factors are determined by performing iterative division by prime numbers in increasing order. 
''Example'' Prime factorisation of <math display="inline">2520</math> <math display="block">\begin{aligned}
2520 | 2& \\
1260 | 2& \\
630 | 2& \\
315 | 3& \\
105 | 3& \\
35 | 5& \\
7 | 7& \\
1 | \mathrm{\ }& \\
\end{aligned}</math>

Prime factorisation is believed to be difficult to perform practically for large number since its time complexity is NP, i.e. superpolynomial (= not bounded above by any polynomial).


=== Congruence ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Modulo operator'''

Definition - modulo operator 
The <math display="inline">a \mod m =</math> the remainder after dividing <math display="inline">a</math> by <math display="inline">m</math>. 
It follows <math display="block">a \mod m = r \equiv a = k*m +r, \mathrm{~where~} 0 <= r < m.</math>

Operator identities of modulo operator are given as

# Distributivity - addition <math display="block">(a+b) \mod n = [(a \mod n) + (b \mod n)] \mod n</math>
# Distributivity - multiplication <math display="block">ab \mod n = [(a \mod n)*(b \mod n)] \mod n</math>
# Distributivity - power <math display="block">a^c \mod m = (a \mod m)^c \mod m</math>

These identities can be proved directly from the definition of the modulo operator. Due to these three identities one can think in modular arithmetic including only addition, multiplication and power, like in regular integer arithmetic without modulo.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Greatest common divisor'''

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Divisability'''''

Definition - divisability 
<math display="inline">n</math> is dividable by a if and only if there exists an integer <math display="inline">k</math> for which <math display="inline">n = a*k</math>. This is denoted by <math display="inline">a|n</math>. The number <math display="inline">a</math> is called the divisor of <math display="inline">n</math>.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Greatest common divisor operator'''''

Definition - greatest common divisor, gcd() operator The greatest common division of the integers <math display="inline">a</math> and <math display="inline">b</math>, <math display="inline">gcd(a,b)</math> is defined by <math display="block">gcd(a,b) = \max_i \{d_i \mathrm{~such~that~} d_i|a \mathrm{~and~} d_i|b\}.</math> An alternative notation of <math display="inline">gcd(a,b)</math> is <math display="inline">(a,b)</math>.

The operator characteristics of the <math display="inline">gcd()</math> operator are given by

# Reflexivity: <math display="block">(a,b) = (b,a).</math>
# <math display="inline">0</math> is neutral element with respect to the operator <math display="inline">gcd()</math>. In other words <math display="block">(a,0) = a.</math>
# The following relation holds <math display="block">(a,b)=(b, a \mod b).</math> Proof. 
<math display="inline">(a,b) = d \Rightarrow a=de, b=df \mathrm{~and~} (e,f)=1</math>. 
Let <math display="inline">e=gf+h</math> be, where <math display="inline">h <f</math>. It follows that <math display="inline">(f,h) =1</math>, since otherwise <math display="inline">f</math> and due to expression of <math display="inline">e</math> also <math display="inline">e</math> were dividable by <math display="inline">(f,h)</math> which would lead to <math display="inline">(e,f)>1</math>. Then <math display="inline">a=de=dgf+dh=gb+dh \Rightarrow a \mod b = dh \mod df=dh</math>, where the last step comes from <math display="inline">h<f</math>. Thus <math display="inline">(b, a \mod b) = (b,dh)=(df,dh) = d</math>, due to <math display="inline">(f,h) =1</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Congruence'''

Definition - relatively prime (also called as coprime) 
The integers <math display="inline">a</math> and <math display="inline">b</math> are relatively prime if and only if <math display="inline">(a,b)=1</math>. 
Definition - congruence 
The congruence is a relation and refers to a base number <math display="inline">m</math>. The integers <math display="inline">a</math> and <math display="inline">b</math> are in congruence relation if and only if <math display="inline">(a\mod m) = (b\mod m)</math> . The congruence id denoted by <math display="inline">a \equiv b\mod m</math>.

Note that <math display="inline">a \equiv b\mod m</math> implies <math display="inline">m|(b-a)</math>. Congruence is an equivalence relation - partitioning the set <math display="inline">\mathbb{Z}</math> to <math display="inline">m</math> disjunct subsets.

Being an equivalence relation, congruence have the following properties: <math display="block">\begin{aligned}
&\mathrm{CP1.~}\mathrm{~ reflexivity~} a \equiv a\mod m\mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~} \\
&\mathrm{CP2.~}\mathrm{~ symmetry~}a \equiv b \mod~m \Rightarrow b \equiv a\mod m\\
&\mathrm{CP3.~}\mathrm{~ transitivity~} a \equiv b\mod m \mathrm{~ and~} b \equiv c\mod m \Rightarrow a \equiv c\mod m \\
\end{aligned}</math>

The operator identities of the congruence refer to given <math display="inline">a \equiv b \mod m</math> and <math display="inline">c \equiv d \mod m</math> and can be given as 
CO1. Adding a constant <math display="inline">\alpha</math> <math display="block">a + \alpha \equiv b + \alpha \mod m.</math> CO2. Multiplication by constant <math display="inline">\alpha</math> <math display="block">\begin{aligned}
&\alpha*a \equiv \alpha*b \mod m.\\
&\Rightarrow -a \equiv -b \mod m.

\end{aligned}</math> CO3. Addition of congruences <math display="block">a+c \equiv b+d \mod m.</math> CO4. Multiplication of congruences <math display="block">a*c \equiv b*d \mod m.</math> CO5. Division by constant <math display="inline">\alpha</math> <math display="block">\alpha*a \equiv \alpha*b \mod m \Rightarrow a \equiv b \mod m.</math>

The first three identities can be proved directly from the definitions of the modulo and congruence operators. The last identity follows from the general identity for division by constant: <math display="block">\alpha*a \equiv \alpha*b \mod m \Leftrightarrow a \equiv b \mod (m/d),</math> where <math display="inline">(\alpha, m) = d</math>. 
Proof: <math display="block">\begin{aligned}
&\alpha*a \equiv \alpha*b \mod m \Leftrightarrow m|[\alpha*(b-a)]\Leftrightarrow \\
&[m/d]|[\alpha/d*(b-a)] \Leftrightarrow [m/d]|[(b-a)],
\end{aligned}</math> since <math display="inline">(m/d,\alpha/d)=1</math>. Then <math display="inline">[m/d]|[(b-a)] \Leftrightarrow a \equiv b \mod (m/d)</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Congruence class'''

Definition - Congruence class modulo <math display="inline">m</math> (also called residue class modulo <math display="inline">m</math>) 
Congruence class modulo <math display="inline">m</math> is any of the disjunct subsets resulted by partitioning the set <math display="inline">\mathbb{Z}</math> by congruence as equivalence relation. In other words congruence class modulo <math display="inline">m</math> is a set <math display="inline">{k \in Z \mathrm{~such~that~} k \equiv a \mod m}</math> for any <math display="inline">a =0,\ldots, (m-1)</math>. For a specific <math display="inline">a</math> the congruence class modulo <math display="inline">m</math> is denoted by <math display="inline">a + m \mathbb{Z}</math>.

The set of all congruence classes modulo <math display="inline">m</math> is denoted by <math display="inline">\mathbb{Z}/m\mathbb{Z}</math>. Thus the number of elements in this set is <math display="inline">m</math>, and this set can be given as <math display="block">\mathbb{Z}/m\mathbb{Z} = \{0+m\mathbb{Z}, 1+m\mathbb{Z},..., (m-1)+m\mathbb{Z}\}.</math>

The set of congruence classes relative prime to <math display="inline">m</math> is denoted by <math display="inline">(\mathbb{Z}/m\mathbb{Z})^*</math>. For any <math display="inline">a</math> representing an element of <math display="inline">(\mathbb{Z}/m\mathbb{Z})^*</math> holds <math display="inline">(a,m) = 1</math>. 
''Example'' <math display="block">(\mathbb{Z}/10\mathbb{Z})^* = \{1+10\mathbb{Z}, 3+10\mathbb{Z}, 7+10\mathbb{Z}, 9+10\mathbb{Z}\}.</math>

If m is prime then number of elements in <math display="inline">(\mathbb{Z}/m\mathbb{Z})^*</math> = <math display="inline">m</math>.


== Diophantic equations ==


=== Euclidean algorithm ===

The Euclidean algorithm is the standard way of solving the equation of the form <math display="block">ax+by=(a,b),</math> where <math display="inline">a,b,x,y \in \mathbb{Z}</math>

'''<math display="inline">\mathrm{\ \ \ \ }</math> Theoretic basics'''

Bézout’s identity 
The greatest common divisor <math display="inline">g</math> of two integers <math display="inline">a</math> and <math display="inline">b</math> can be represented as a linear sum of the original two numbers <math display="inline">a</math> and <math display="inline">b</math>. In other words

<math display="block">\exists x,y \in \mathbb{Z}, \mathrm{~for~which~} g = (a,b)=ax+by.</math>

Theorem 
The set of all integer linear combinations of the nonzero integer <math display="inline">a</math> and <math display="inline">b</math> equals the set of integer muliples of <math display="inline">(a,b)</math>, i.e: <math display="block">a\mathbb{Z}+b\mathbb{Z}=(a,b)\mathbb{Z},</math>

Proof:

* Step 1: direction <math display="inline">\Rightarrow</math> <math display="inline">a\mathbb{Z}+b\mathbb{Z} \in (a,b)\mathbb{Z}</math> - follows from definition of <math display="inline">(a,b)</math>
* Step 2: direction <math display="inline">\Leftarrow</math> <math display="inline">(a,b)\mathbb{Z} \in a\mathbb{Z}+b\mathbb{Z}</math> - follows from Bézout’s identity <math display="inline">(a,b)=ax+by, \mathrm{~where~} x,y \in \mathbb{Z} \Rightarrow (a,b)\mathbb{Z} = ax\mathbb{Z}+by\mathbb{Z}</math>

Corollary 1 
The equation <math display="block">ax+by = n, \mathrm{~where~} a,b,x,y,n \in \mathbb{Z} \mathrm{~and~} a\neq 0, b\neq 0</math> has a solution if and only if <math display="inline">(a,b)|n</math>. 
Proof: It follows directly from the above theorem. 
Notes:

* Case 1: If <math display="inline">(a,b) = 1</math> then the equation has always a solution.
* Case 2: If <math display="inline">(a,b) = d \neq 1</math> then this case can be fallbacked to Case 1: <math display="block">\begin{aligned}
&a=de, b=df \mathrm{~and~} (e,f) = 1~(\mathrm{otherwise~} (a,b) > d)\\
&dex+dfy=dg, \mathrm{~then~dividing~by~}d\\
&ex+fy=g, \mathrm{~where~} (e,f) = 1.

\end{aligned}</math>

Corollary 2 
The equation <math display="block">ax+by = (a,b), \mathrm{~where~} a,b,x,y \in \mathbb{Z}\mathrm{~and~}a\neq0, b\neq0</math> has always a solution. 
Proof: It follows directly from Corollary 1.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Solution of equation <math display="inline">ax+by = (a,b)</math>'''

The solution of the equation <math display="block">ax+by = (a,b)</math> consists of two steps as

# determination of <math display="inline">(a,b)</math> - by means of base variant of Euclidean algorithms and
# determination of <math display="inline">x</math> and <math display="inline">y</math> - by means of the extended variant of the algorithm.

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Euclidean algorithm - base variant'''''

The idea of the base variant of Euclidean algorithms is the recursive application of <math display="inline">(a,b) = (b, a \mod b)</math> until <math display="inline">(h,0) = h</math>. 
''Example'' - determination of <math display="inline">(a,b)</math>:

<math display="block">\begin{aligned}
&455x + 135y = (455,135)\\
&\\
&455 = 3*135 + 50\\
&135 = 2*50 + 35\\
&50 = 1*35 + 15\\
&35 = 2*15 + 5\\
&15 = 3* 5 + 0\\
&\\
&\Rightarrow (455,135) = 5\\
\end{aligned}</math>

The Pseudo code of determination gcd(a,b) (as well as storing the coefficients q[i]-s) by means of the base variant of the Euclidean algorithm can be given as

<math display="block">\begin{aligned}
&h = a; \mathrm{~the~higher~value~} \\
&s = b \mathrm{~the~smaller~value~} \\
&i = 0; \\
&while (s > 0) \mathrm{~until~} s \mathrm{~reaches ~} 0 \\
&\{ \\
&\mathrm{\ \ }q[i++] = h \div s; \\
&\mathrm{\ \ }t = s; \\
&\mathrm{\ \ }s = h \% s; \mathrm{~next~} s \\
&\mathrm{\ \ }h = t; \mathrm{~next~} h \\
&\} \\
&n = i-1; \\
&gcd = h; \\
\end{aligned}</math>

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Euclidean algorithm - extended variant'''''

The extended Euclidean algorithm is used to determine the unknowns <math display="inline">x</math> and <math display="inline">y</math> after carrying out the base variant of the Euclidean algorithm. This is a necessary previous step, since the extended Euclidean algorithm uses the quotient and remainders computed in the course of executing the steps of the base variant of Euclidean algorithms. The idea of extended Euclidean algorithm is a recursive application of backward substitution based on the steps of the base variant of Euclidean algorithms. This is shown in the next example. 
''Example'' - determination of <math display="inline">x</math> and <math display="inline">y</math>:

<math display="block">\begin{aligned}
&455x + 135y = 5 \\
& \\
& \mathrm{~Starting~with~last~but~one~line~of~the~solution~by~the~base~variant~we~get~} \\
5 &= 35 - 2*15 = \\
&= 35 - 2*(50 - 1*35) = -2*50 + 3*35 = \\
&= -2*50 + 3*(135 - 2*50) = 3*135 - 8*50 = \\
&= 3*135 - 8*(455 - 3*135) = -8*455 + 27*135
&\\
&\Rightarrow x=-8, y=27
\end{aligned}</math>

'''''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> The time complexity'''''

The time complexity of both the base and extended variant of Euclidean algorithm is <math display="inline">O((\log h)^2)</math>, where <math display="inline">h</math> is the number of digits in the smaller number among <math display="inline">a</math> and <math display="inline">b</math>.


=== Fermat–Euler theorem and little Fermat theorem) ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Euler’s phi function'''

Definition - <math display="inline">\phi(n)</math> 
Euler’s phi function, <math display="inline">\phi(n)</math>, also called as Euler’s totient function, is defined as the number of integers <math display="inline">k</math> in the range <math display="inline">1 \leq k \leq n</math>, for which <math display="inline">k</math> and <math display="inline">n</math> are relatively primes. In other words

<math display="block">\phi(n) = |{1<=k<=n \mathrm{~such~that~} (k,n)=1}|,</math> where <math display="inline">|A|</math> stands for the cardinality of the set <math display="inline">A</math>. Note that <math display="inline">\phi(n)</math> never includes <math display="inline">n</math>, since<math display="inline">(n,n) = n \neq 1</math>. <math display="block">\Rightarrow \phi(n) <= n-1.</math>

''Example'' - Computation of <math display="inline">\phi(10)</math>

<math display="block">\begin{aligned}
&\{{1<=k<=10 \mathrm{~such~that~} (k,10)=1}\} = \{1,3,7,9\} \\
&\Rightarrow \phi(10) = |{1,3,7,9}| = 4.

\end{aligned}</math>

The properties of <math display="inline">\phi(n)</math> can be given as

# If p is prime then <math display="inline">\phi(p) = p-1</math>.
# If (m,n)=1 then <math display="inline">\phi(m*n)=\phi(m)*\phi(n)</math>.
# If p and q are prime then <math display="inline">\phi(p*q) = (p-1)*(q-1)</math> 
Proof. This property follows from properties 2. and 1.
# In general <math display="inline">\phi(n)</math> can be expressed by the prime factorisation of <math display="inline">n</math> as <math display="inline">\phi(n) = n*\prod_{i=1}^{k} (1-1/p_i)</math>, where <math display="inline">n=\prod_{i=1}^{k}p_i^{e_i}</math>.

The order of congruence classes relative prime to <math display="inline">m</math>, <math display="inline">(\mathbb{Z}/m\mathbb{Z})^*</math> is exactly <math display="inline">\phi(m)</math>. If m prime then this order is <math display="inline">m-1</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Fermat–Euler theorem'''

Fermat–Euler theorem - also called as Euler’s theorem. 
If <math display="inline">a</math> and <math display="inline">n</math> are relatively prime then

<math display="block">a^{\phi(n)} \equiv 1 \mod n.</math>

'''<math display="inline">\mathrm{\ \ \ \ }</math> Fermat’s little theorem'''

Fermat’s little theorem - If <math display="inline">n</math> is prime and <math display="inline">a</math> and <math display="inline">n</math> are relatively prime then <math display="block">a^{p-1} \equiv 1 \mod n.</math>

Fermat’s little theorem is a special case Fermat–Euler theorem for the case where <math display="inline">n</math> is prime.


=== Modular multiplicative inverse and its computation ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Residue systems modulo <math display="inline">m</math>''' 
Definition - Complete system of residues modulo m 
The complete system of residues modulo <math display="inline">m</math> is any set of <math display="inline">m</math> integers so that each element comes from a different congruence class modulo <math display="inline">m</math>. 
Definition - Least residue system modulo <math display="inline">m</math> 
Least residue system modulo <math display="inline">m</math> is the set 0,1,..., m-1. 
Definition - Reduced residue system modulo <math display="inline">m</math> 
Reduced residue system modulo <math display="inline">m</math> is a set obtained from complete system of residues modulo <math display="inline">m</math> by deleting all elements being not coprime with <math display="inline">m</math>.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Modular multiplicative inverse of an integer'''

Definition - Modular multiplicative inverse of an integer <math display="inline">a</math> 
The modular multiplicative inverse of an integer <math display="inline">a</math>, is the integer x that is given by <math display="block">ax \equiv 1 \mod m.</math>

Observe, that not every elements of a complete system of residues modulo <math display="inline">m</math> has modular multiplicative inverse ! 
Theorem 
An integer <math display="inline">a</math> element of complete system of residues modulo <math display="inline">m</math> has modular multiplicative inverse if and only if <math display="inline">a</math> and <math display="inline">m</math> are relatively prime, in other words if <math display="inline">(a,m) = 1</math>. 
Proof: <math display="block">\begin{aligned}
&ax \equiv 1 \mod m \Leftrightarrow ax + bm = 1\\
&\mathrm{~The~equation~} ax + my = 1 \mathrm{~has~solution~if~and~only~if~} (a,m) = 1.

\end{aligned}</math>

The modular multiplicative inverse of integer <math display="inline">a</math> is denoted by <math display="inline">a^{-1}</math>. This can be explained by dividing the relation the relation <math display="inline">ax \equiv 1 \mod m</math> formally by <math display="inline">a</math>. With this notation holds the relation <math display="block">a^{-1} \equiv x \mod m \Leftrightarrow ax \equiv 1 \mod m.</math>

If exists, the modular multiplicative inverse of an integer <math display="inline">a</math> is determined uniquely 
Corollary 
If <math display="inline">m</math> is prime then each of the elements <math display="inline">{1,..., m-1}</math> of the least residue system modulo <math display="inline">m</math> has modular multiplicative inverse. 
Proof: Each element of <math display="inline">{1,..., m-1}</math> and <math display="inline">m</math> are relatively primes.

'''<math display="inline">\mathrm{\ \ \ \ }</math> Computation of the modular multiplicative inverse'''

The modular multiplicative inverse of an integer <math display="inline">a \mod m, (a,m)=1</math> can be computed on the following ways.

<ul>
<li>Computation way 1. - by using the extended Euclidean algorithm <math display="block">ax \equiv 1 \mod m \Leftrightarrow ax + bm = 1.</math>
Due to <math display="inline">(a,m)=1</math> the equation <math display="inline">ax + bm = 1</math> has solution. <math display="inline">\Rightarrow</math> Solving the equation <math display="inline">ax + bm = 1</math> by the extended Euclidean algorithm, <math display="inline">x</math> gives the modular multiplicative inverse of an integer <math display="inline">a \mod m</math>.</li>
<li>Computation way 2. - by means of efficient computation of raising an integer to a higher power, using a formula based on Euler’s theorem <math display="block">a^{\phi(n)-1}*a \equiv 1 \mod n \Rightarrow a^{-1} \equiv a^{\phi(n)-1} \mod n</math> <math display="inline">\Rightarrow</math> The the modular multiplicative inverse of an integer <math display="inline">a \mod m</math> are given by <math display="inline">a^{\phi(n)-1} \mod n</math>, which can be determined by efficient computation of a modular multiplicative inverse - by using exponentiation by squaring.</li></ul>

'''<math display="inline">\mathrm{\ \ \ \ }</math> Modular exponentiation by squaring'''

Modular exponentiation is raising an integer to a higher power modulo <math display="inline">n</math>, in other words computing <math display="inline">g^e \mod n</math>. Exponentiation by squaring is an efficient computation of modular exponentiation. The idea of exponentiation by squaring is to compute <math display="inline">g^e \mod n</math> by the help of successive squares of <math display="inline">g</math>. This can be implemented as follows.

* Rearrange <math display="inline">g^e</math> by using the binary representation of <math display="inline">e</math> <math display="block">g^e = g^{(\sum_{i=0}^{k}e_i*2^i)} = \prod_{i=0}^{k} g^{e_i*2^i}.</math> <math display="inline">\Rightarrow</math> Only those terms of the product must be computed, for which <math display="inline">e_i=1</math>, since for <math display="inline">e_i=0</math> the term <math display="inline">g^{e_i*2^i}</math> becomes <math display="inline">g^{0*2^i}=1</math>. <math display="inline">\Rightarrow</math> The terms with <math display="inline">e_i=1</math> becomes powers of <math display="inline">g</math> as <math display="inline">g^{2^i}</math>.
* Computation of the powers <math display="inline">g^{2^i}</math> successively by applying <math display="block">g^{2^{l+1}} = (g^{2^l})^2 \mathrm{~for~} l>=0</math>
* Computate each term with mod <math display="inline">n</math>.

''Example'' - Exponentiation by squaring

<math display="block">\begin{aligned}
&3^{52} \mod 100 \\
& \\
&52 = 110100 = 2^2+2^4+2^5 \\
&3^{(2^0)} = 3\\
&3^{(2^1)} = 3^2 = 9\\
&3^{(2^2)} = 9^2 = 81\\
&3^{(2^3)} = 81^2 \mod 100 = 61\\
&3^{(2^4)} = 61^2 \mod 100 = 21\\
&3^{(2^5)} = 21^2 \mod 100 = 41\\
&\\
&3^{52} \mod 100 = 81*21*41 \mod 100 = 41.
\end{aligned}</math>

<math display="inline">\Rightarrow</math> Conclude that instead of 52 multiplications only 5 squaring and 3 multiplications were needed.


=== Discrete logarithm ===

'''<math display="inline">\mathrm{\ \ \ \ }</math> Primitive root modulo m'''

Definition - primitive root modulo <math display="inline">m</math> 
The number <math display="inline">g</math> is primitive root modulo <math display="inline">m</math> if for every integer <math display="inline">a</math> being coprime to <math display="inline">m</math> (i.e. <math display="inline">(a,m)=1</math>) there is an integer <math display="inline">k</math> for which <math display="inline">g^k \equiv a \mod n</math>. 
Interpretation 
All elements of the set of congruence classes coprime to <math display="inline">n</math>, <math display="inline">(\mathbb{Z}/m\mathbb{Z})^*</math> can be generated by power of <math display="inline">g</math> modulo <math display="inline">m</math>. Therefore

* <math display="inline">g</math> is also called as generator of the set of congruence classes coprime to <math display="inline">m</math> and
* <math display="inline">g</math> must be coprime to <math display="inline">m</math>.

Definition - Multiplicative order of primitive root modulo <math display="inline">m</math> 
The multiplicative order of primitive root modulo <math display="inline">m</math> is the lowest power of a which is congruent to <math display="inline">1</math> modulo <math display="inline">m</math>. 
Statement The multiplicative order of primitive root modulo <math display="inline">m</math> is <math display="inline">\phi(m)</math>.

This is because

* this power of a is congruent to <math display="inline">1</math> modulo <math display="inline">n</math>, since <math display="inline">a^{\phi(m)} \equiv 1 \mod n</math> due to Euler’s theorem and
* this is the lowest power as the other lower powers are needed to generate the other elements of the set <math display="inline">(\mathbb{Z}/m\mathbb{Z})^*</math>.

It follows that if <math display="inline">m</math> is prime then the multiplicative order <math display="inline">\phi(m) = m-1</math>.

Note that not all elements of <math display="inline">(\mathbb{Z}/m\mathbb{Z})^*</math> are primitive root modulo m ! However the non-primitive root modulo <math display="inline">m</math> elements are cyclic generator of a subset of <math display="inline">(\mathbb{Z}/m\mathbb{Z})^*</math>. The non-primitive root elements of <math display="inline">(\mathbb{Z}/m\mathbb{Z})^*</math> have also multiplicative order, which is can be however less then <math display="inline">\phi(m)</math>. 
''Example'' - <math display="inline">m=7</math> prime <math display="block">\begin{aligned}
&(\mathbb{Z}/7\mathbb{Z})^* - \mathrm{~least~residue~system~modulo~} 7 = {0,1,..., 6}\mathrm{~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~}\\
&\mathrm{~~The~elements~} 3 \mathrm{~and~} 4 \mathrm{~are~primitive~root~modulo~} m. \\
&\mathrm{~~For~example~the~element~} 2 \mathrm{~is~not~primitive~root~modulo~} m!\\
&\mathrm{~~}\Rightarrow \mathrm{~~Multiplicative~order~of~} 2 \mathrm{~is~} 3 < \phi(7)=6, \mathrm{~since~} 2^3 \equiv 1 \mod 7.
\end{aligned}</math>

'''<math display="inline">\mathrm{\ \ \ \ }</math> Discrete logarithm to the base <math display="inline">g</math> modulo <math display="inline">m</math>''' 
Definition - Discrete logarithm (also called index) 
Discrete logarithm, also called index When <math display="inline">a=g^k \equiv a \mod m</math> then the <math display="inline">k</math> is called as discrete logarithm of the integer <math display="inline">a</math> to the base <math display="inline">g</math> modulo <math display="inline">m</math>. Here <math display="inline">g</math> is primitive root modulo <math display="inline">m</math>, and <math display="inline">a</math> is an element of <math display="inline">(\mathbb{Z}/m\mathbb{Z})^*</math>, i.e. <math display="inline">a</math> coprime to <math display="inline">m</math>.

The practical importance of the discrete logarithm lies in its property that computation of discrete logarithm is believed to be difficult to perform, especially for some specific groups.


== Application to cryptography ==

'''<math display="inline">\mathrm{\ \ \ \ }</math> RSA cryptography'''

RSA is a cryptosystem, called after its developers: Rivest, Shamir and Adleman. The principle of the key generation can be described by means of the following steps.

* Step 1. Select large primes <math display="inline">p</math> and <math display="inline">q</math>, e.g. each of them with size <math display="inline">512</math> bits.
* Step 2. Compute <math display="inline">n=p*q</math>
* Step 3. Compute <math display="inline">\phi(n)= (p-1)*(q-1)</math>
* Step 4. Select a random integer <math display="inline">1 < e < \phi(n)</math>, such that <math display="inline">e</math> is coprime to <math display="inline">\phi(n)</math>
* Step 5. Determine an integer <math display="inline">1 < d < \phi(n)</math>, such that <math display="inline">e*d \mod \phi(n) = 1</math>, i.e. <math display="inline">d</math> is modular multiplicative inverse of <math display="inline">e</math>. 
<math display="inline">\Rightarrow</math> The integer <math display="inline">d</math> can be computed
** either by using the extended Euclidean algorithm
** or by the help of Euler’s theorem and using exponentiation by squaring.

The keys are called as

* private key = d
* public keys = e, n

Secret parameters of the key generation: <math display="inline">p, q, \phi(n)</math>.

The usage of RSA for encryption can be explained as

* Notation: <math display="inline">m</math> = message, <math display="inline">c</math> = chipertext - both in form natural numbers
* Condition: <math display="inline">m < n</math> - needed for the correct decryption, see below.
* The encryption end decryption processes
** The encryption <math display="block">c = m^e \mod n,</math>
** The decryption <math display="block">m' = c^d \mod n</math>

The correctness of the RSA cryptographic algorithm can be shows by showing <math display="block">m'=m</math>

Proof: Using the way of generation of <math display="inline">d</math> we have <math display="block">e*d \mod \phi(n) = 1 \Rightarrow e*d = 1 + k*\phi(n)</math> By using it, the decrypted chipertext <math display="inline">m'</math> can be rearranged as <math display="block">\begin{aligned}
m' &= c^d\mod n = (m^e)^d\mod n = m^{e*d}\mod n = m^{1 + k*\phi(n)}\mod n =\\
&= [(m^1\mod n) * ((m^{\phi(n)})^k\mod n)]\mod n = \\
& \mathrm{\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ } \uparrow \mathrm{~condition~} m < n \\
&= [m * ((m^{\phi(n)} \mod n)^k) \mod n] \mod n = \\
&\mathrm{\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ } \uparrow \mathrm{~Euler's~theorem~}\\
&= (m * 1) \mod n = m \\
&\mathrm{\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ } \uparrow \mathrm{~condition~} m < n.
\end{aligned}</math>

Note, that proof of correctness is also possible by using Fermat’s little theorem utilizing the fact that <math display="inline">n = p*q</math>, i.e. multiplication of two primes.

RSA can be used both for

* encryption and
* authentication,

in both cases including key distribution. Proof of correctness for using RSA for authentication can be shown similar to that one provided for the case of using it for encryption.

The secrecy of RSA is based on the computational difficulty of prime factorization. 
<math display="inline">\Rightarrow</math> If n could be factorized on efficient way then the secrecy of RSA would be broken !!

'''<math display="inline">\mathrm{\ \ \ \ }</math> Diffie–Hellman key exchange'''

Diffie–Hellman key exchange is a protocol for secure key distribution. The principle of the solution is to generate the common secret key without exchanging the key itself. This is achieved on the way that each party shares only a partial info on the key to be generated.

The Diffie-Hellman key establishment protocol can be described by the following steps.

* Step 1. The parties A and B agree on a prime <math display="inline">p</math> and a natural number <math display="inline">1 < g < p</math>, which is a primitive root modulo <math display="inline">p</math>.
* Step 2. Each party selects a secret number <math display="inline">\alpha < p-1</math> and <math display="inline">\beta < p-1</math>, and computes the power <math display="inline">a = g^{\alpha} \mod p</math> and <math display="inline">b = g^{\beta} \mod p</math>, respectively.
* Step 3. Each party sends <math display="inline">a</math> and <math display="inline">b</math> to the other party.
* Each party computes the common secret key <math display="inline">k</math> based on the received numbers <math display="inline">a</math> and <math display="inline">b</math> as <math display="inline">k =a^{\beta} \mod p</math> and <math display="inline">k = b^{\alpha} \mod p</math>.

Keys arising in the key exchange protocol are classified as

* Public keys: <math display="inline">p, g, a</math> and <math display="inline">b</math>
* Private keys: <math display="inline">\alpha</math> and <math display="inline">\beta</math>

The operation way of the Diffie-Hellman key exchange protocol is shown in Figure [[#fig:Diffie-Hellman_ke|1]].

<div id="fig:Diffie-Hellman_ke" class="figure">

[[File:./figs/Diffie-Hellman_key_exchange.pdf]]

</div>
The equality of the keys generated on the different sides can be shown as follows. <math display="block">\begin{aligned}
a^{\beta} \mod p &= (g^{\alpha})^{\beta} \mod p = g^{\alpha * \beta} \mod p = \\
&= (g^{\beta})^{\alpha} \mod p = b^{\alpha} \mod p \\
\end{aligned}</math>

The secrecy of Diffie-Hellman key exchange protocol is based on the computational difficulty of the discrete logarithms, more precisely on determining <math display="inline">\alpha</math> from <math display="inline">a = g^{\alpha} \mod p</math> or <math display="inline">\beta</math> from <math display="inline">b = g^{\beta} \mod p</math> in the knowledge of <math display="inline">g</math> and <math display="inline">a</math> or <math display="inline">b</math> and <math display="inline">p</math>.


== Combinatorics ==

For an introduction to basics of combinatorics see [https://en.wikipedia.org/wiki/Permutation Permutation] and [https://en.wikipedia.org/wiki/Combination Combination].


== Relations ==

For an introduction and overview on mathematical relations see [https://en.wikipedia.org/wiki/Relation_(mathematics) Relation].

2024-09-24T12:17:03Z

SAFFER Zsolt:

Benutzer:SAFFER Zsolt

2024-09-24T12:10:07Z

SAFFER Zsolt: Die Seite wurde neu angelegt: „Zsolt Saffer - kurze Biografie Zsolt Saffer studierte Elektrotechnik und Informatik an der Technischen Universität Budapest, später genannt als Technische und Wirtschaftswissenschaftliche Universität Budapest (BUTE). Mehr als ein Jahrzehnt lang war er als Software- und Technologieentwicklungsingenieur bei Alcatel Austria, Wien und Philips Speech Recognition Systems, Wien tätig. Er hat im Fach Informatik in 2010 promoviert. Er hat zahlreiche wissensch…“

Zsolt Saffer - kurze Biografie

Zsolt Saffer studierte Elektrotechnik und Informatik an der Technischen Universität Budapest, später genannt als Technische und Wirtschaftswissenschaftliche Universität Budapest (BUTE). Mehr als ein Jahrzehnt lang war er als Software- und Technologieentwicklungsingenieur bei Alcatel Austria, Wien und Philips Speech Recognition Systems, Wien tätig. Er hat im Fach Informatik in 2010 promoviert. Er hat zahlreiche wissenschaftliche Artikel veröffentlicht und habilitierte sich als Privatdozent 2019 im Fach Angewandte Mathematik an der Technische Universität Wien. Er ist Lehrer für mathematische Stochastik an der Technische Universität Wien seit 2018. Ab Oktober 2023 ist er hauptberuflich als wissenschaftlicher Mitarbeiter an der FernFH tätig. Seine aktuellen Forschungsinteressen umfassen künstliche Intelligenz, maschinelles Lernen, Warteschlangentheorie und ihre Anwendungen vor allem in Gesundheitswesen, stochastische Modellierung vor allem im Bereich erneuerbarer Energien, vernetzte Fahrzeuge und Optimierung.

Literatur

2024-09-16T17:34:00Z

SAFFER Zsolt:

<div class="thebibliography">

[Duda et al.(2001)] Richard O Duda, Peter E. Hart, David G. Stork. ''Pattern Classification''. John Wiley & Sons, 2001.

[Siddique et al.(2013)] Nazmul Siddique, Hojjat Adeli. ''Computational Intelligence: Synergies of Fuzzy Logic, Neural Networks and Evolutionary Computing''. John Wiley & Sons, 2013.

[FloridiCowls(2019)]Luciano Floridi, Josh Cowls: A Unified Framework of Five Principles for AI in Society. In ''Harvard Data Science Review'', Band 1, Nr. 1, 2019. doi:10.1162/99608f92.8cd550d1

[Devlin et al.(2019)] Jacob Devlin, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding. In ''North American Chapter of the Association for Computational Linguistics: Human Language Technologies.'', 2019.

[Mikolov et al.(2013)] Tomas Mikolov, Ilya Sutskever, Kai Chen, Gregory S. Corrado, and Jeffrey Dean. Distributed Representations of Words and Phrases and their Compositionality. In ''NIPS.'', 2013.

[Vaswani et al.(2017)] Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In ''Advances in neural information processing systems, 30'', 2017.

[Yamada et al.(2018)] Ikuya Yamada, Akari Asai, Jin Sakuma, Hiroyuki Shindo, Hideaki Takeda, Yoshiyasu Takefuji, and Yuji Matsumoto. Wikipedia2vec: An efficient toolkit for learning and visualizing the embeddings of words and entities from wikipedia. In ''arXiv preprint arXiv:1812.06280'', 2018.

[Bengio(2008)] Yoshua Bengio. Neural net language models. ''Scholarpedia.'', 3:3881, 2008. https://doi.org/10.4249/scholarpedia.3881

[3] G. A Miller. WordNet: A Lexical Database for English. ''Commun. ACM'', 38(11), 39-41, Nov. 1995.

[4] O. Bodenreider. The Unified Medical Language System (UMLS): integrating biomedical terminology. ''Nucleic Acids Research'', 32, no. Database issue, D267–270, Jan. 2004.

[5] K. Bollacker, C. Evans, P. Paritosh, T. Sturge, and J. Taylor. Freebase: a collaboratively created graph database for structuring human knowledge. In ''Proceedings of the 2008 ACM SIGMOD international conference on Management of data. ACM'', 1247–1250, 2008.

[6] D. Vrandecic and M. Krötzsch. Wikidata: a free collaborative knowledgebase. ''Communications of the ACM'', 57(10), 78–85, 2014.

[1] J. Hoffart, F. M. Suchanek, K. Berberich, and G. Weikum. YAGO2: a spatially and temporally enhanced knowledge base from Wikipedia. ''Artificial Intelligence'', 194, 28–61, 2013.

[7] S. Auer, C. Bizer, G. Kobilarov, J. Lehmann, R. Cyganiak, and Z. Ives. ''DBpedia: A Nucleus for a Web of Open Data''. in The Semantic Web. Springer Berlin Heidelberg, vol. 4825, pp. 722–735, 2007.

[8] A. Carlson, J. Betteridge, B. Kisiel, B. Settles, E. R. H. Jr, and T. M. Mitchell. Toward an Architecture for Never-Ending Language Learning. In ''Proceedings of the Twenty-Fourth Conference on Artificial Intelligence (AAAI 2010), AAAI Press'', 1306–1313, 2010.

[2] X. Dong, E. Gabrilovich, G. Heitz, W. Horn, N. Lao, K. Murphy, T. Strohmann, S. Sun, and W. Zhang. Knowledge Vault: A Web-scale Approach to Probabilistic Knowledge Fusion. In ''Proceedings of the 20th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining. New York, NY, USA: ACM'', 601–610, 2014.

[9] J. Fan, D. Ferrucci, D. Gondek, and A. Kalyanpur, Prismatic: Inducing knowledge from a large scale lexicalized relation resource. In ''Proceedings of the NAACL HLT 2010 First International Workshop on Formalisms and Methodology for Learning by Reading, Association for Computational Linguistics'', 122–127, 2010.

[Biswas(2003)] Russa. Biswas. ''Embedding Based Link Prediction for Knowledge Graph Completion. Ph. D. dissertation''. PhD thesis, Karlsruher Institut für Technologie (KIT), Germany, 2003. https://doi.org/10.5445/IR/1000156436

[Ji et al.(2022)] S. Ji, S. Pan, E. Cambria, P. Marttinen and P. S. Yu,. A Survey on Knowledge Graphs: Representation, Acquisition, and Applications. In ''IEEE Transactions on Neural Networks and Learning Systems'', 33(2),494-514, 2022. doi: 10.1109/TNNLS.2021.3070843

[Nickel et al.(2016)] M. Nickel, K. .Murphy, V. Tresp, and E. Gabrilovich. A Review of Relational Machine Learning for Knowledge Graphs. In ''Proceedings of the IEEE, Institute of Electrical and Electronics Engineers (IEEE)'', 104(1):11-33, 2016. http://dx.doi.org/10.1109/JPROC.2015.2483592

[Kejriwal(2022)] Mayank Kejriwal. Knowledge Graphs: A Practical Review of the Research Landscape. ''Information'', 13(4), 161, 1-17, 2022. https://doi.org/10.3390/info13040161

[Pflueger et al.(2022)] Maximilian Pflueger, David J. Tena Cucala, and Egor V. Kostylev. GNNQ: A Neuro-Symbolic Approach to Query Answering over Incomplete Knowledge Graphs. In ''The Semantic Web – ISWC 2022, Springer International Publishing'', 481–497, 2022.

[Pan et al.(2024)] Shirui Pan, Linhao Luo, Yufei Wang, Chen Chen, Jiapu Wang, and Xindong Wu. Unifying Large Language Models and Knowledge Graphs: A Roadmap. ''IEEE Transactions on Knowledge and Data Engineering, Institute of Electrical and Electronics Engineers (IEEE)'', 56(4), 1–20, 2024. http://dx.doi.org/10.1109/TKDE.2024.3352100

[Zhong et al.(2023)] Lingfeng Zhong, Jia Wu, Qian Li, Hao Peng, and Xindong Wu. A Comprehensive Survey on Automatic Knowledge Graph Construction. ''ACM Computing Surveys'', 56(4), Article No.: 94, 1–62, 2023. https://doi.org/10.1145/3618295

[Fisher(1936)] R.A. Fisher. The Use of Multiple Measurements in Taxonomic Problems. ''Annals of Eugenics.'', 7 (2): 179–188, 1963. https://doi:10.1111/j.1469-1809.1936.tb02137.x.

[Vapnik and Chervonenkis(1971)] V. N. Vapnik, and A. Y. Chervonenkis. On the uniform convergence of relative frequencies of events to their probabilities. ''Theory of Probability and Its Applications'', 16, 264–280, 1971.

[Blumer et al.(1989)] A. Blumer, A. Ehrenfeucht, D. Haussler, and M. K. Warmuth. Learnability and the Vapnik–Chervonenkis dimension. ''Journal of the ACM'', 36(4), 929––865, 1989.

[Vapnik(1995)] V. N. Vapnik. ''The Nature of Statistical Learning Theory''. Springer, New York., 1995.

[Wolpert9(1996)] D. H. Wolpert. The lack of a priori distinction between learning algorithms. ''Neural Computation'', 8(7), 1341–1390, 1996.

[McCulloch and Pitts(1943)] W. S. McCulloch and W. Pitts. A logical calculus of ideas immanent in nervous activity. ''Bulletin of Mathematical Biophysics'', 5, 115–133, 1943.

[Rosenblatt(1958)] Frank Rosenblatt. The perceptron. A probabilistic model for information storage and organization in the brain. ''Psychological Reviews'', 65, 386–408, 1958.

[Goodfellow et al.(2016)] I. Goodfellow, Y. Bengio, and A. Courville. ''Deep Learning''. MIT Press, 2016.

[Reynolds(2021)] Anh Reynolds. ''Understanding convolutional neural networks (cnns).'' https://anhreynolds.com/blogs/cnn.html, 2021 Accessed: 2024-02-11.

[JurafskyMartin(2023)] Daniel Jurafsky and James H. Martin. ''Speech and Language Processing''. https://web.stanford.edu/ jurafsky/slp3, 2023

[Hochreiter(1991)] S. Hochreiter. ''Untersuchungen zu dynamischen neuronalen Netzen. Diplom thesis''. Diplom thesis, Institut f. Informatik, Technische Univ. Munich., Germany, 1991.

[CARTPennStateCourse(2024)] Penn State’s Department of Statistics. ''Course notes for STAT 508: Applied Data Mining and Statistical Learning, Lesson 11''. https://online.stat.psu.edu/stat508/, 2024 Creative Commons license CC BY-NC 4.0

[Breiman(1996)] Leo Breiman. Bagging predictors. ''Machine Learning'', 24(2), 123–140, 1996. doi:10.1007/BF00058655

[Elman(1990)] J. L. Elman. Finding structure in time. ''Cognitive science'', 14(2), 179–211, 1990.

[Werbos(1974)] P. Werbos. ''Beyond regression: new tools for prediction and analysis in the behavioral sciences. Ph.D. thesis''. Ph.D. thesis, Harvard University, USA, 1974.

[SchusterPaliwal(1997)] M. Schuster and K. K. Paliwal. Bidirectional recurrent neural networks. ''IEEE Transactions on Signal Processing'', 45, 2673–2681, 1997.

[HochreiterSchmidhuber(1997)] S. Hochreiter and J. Schmidhuber. Long short-term memory. ''Neural Computation'', 9(8),1735–1780, 1997.

[Bellman(1957)] Richard Bellman. A Markovian Decision Process. ''Journal of Mathematics and Mechanics'', 6(5):679–684, 1957. http://www.jstor.org/stable/24900506

[Bertsekas(1987)] Dimitri P. Bertsekas. Dynamic Programming: Deterministic and Stochastic Models. Prentice-Hall, 1987.

[LittmanDeanKaelbling(1995)] M. L. Littman, T. L. Dean, and L. P. Kaelbling. On the complexity of solving Markov decision problems. In ''Proceedings of the Eleventh Annual Conference on Uncertainty in Articial Intelligence (UAI-95)'', Montreal, Québec, Canada, 1995.

[Li(2018)] Y. Li. Deep reinforcement learning. . https://arxiv.org/abs/1810.06339 arXiv:1810.06339

[Son et al.(2022)] Ki Young Son, Jongwoo Ko, Eunseok Kim, Si Young Lee, Min-Ji Kim, Jisang Han, Eunhae Shin, Tae-Young Chung, and Dong Hui Lim. Deep learningbased cataract detection and grading from slit-lamp and retro-illumination
photographs: Model development and validation study.. ''Ophthalmology Science'', 2(2), 2022.

</div>

Evaluierung und Verbesserung von AI-Modellen

2024-09-16T17:32:10Z

SAFFER Zsolt:

= Evaluierung und Verbesserung von KI-Modellen =


== Evaluierung von Klassifikations- und Regressionsmodellen ==


=== Bewertungsmetriken zur Klassifizierung ===

Ein Klassifizierungsmodell wird anhand der Testdaten ausgewertet. Die zur Bewertung des Modells am häufigsten verwendeten allgemeinen Bewertungsmetriken (evaluation metrics) sind wie folgt aufgeführt:

* Accuracy (Genauigkeit),
* Konfusionsmatrix (confusion matrix),
* Precision und Recall (Präzision und Rückruf),

Die Accuracy ist das Verhältnis der korrekt klassifizierten Beispiele zur Gesamtzahl der Beispiele im Testdaten. Definiert man wahre Beispiele (true examples - TE) und falsche Beispiele (false examples - FE) als Anzahl der korrekt und falsch klassifizierten Beispiele im Testdaten, kann die Accuracy wie folgt angegeben werden:

<math display="block">\mathrm{Accuracy} = \frac{TE}{TE+FE}.</math>

Die Konfusionsmatrix ist eine Metrik zur Visualisierung der Klassifizierungsleistung (classification performance). Die Zeilen der Matrix stellen die wahren Klassen dar und die Spalten zeigen die vorhergesagten Klassen. Das Element (i,j) der Matrix zeigt die Anzahl der Testbeispiele, die zur Klasse i gehören und als Klasse j klassifiziert sind. Die Konfusionsmatrix zeigt also nicht nur die Anzahl der korrekt klassifizierten Beispiele für jede Klasse, sondern auch eine Vorstellung von typischen Fehlklassifizierungen, die das Modell vornimmt. Eine Beispiel-Konfusionsmatrix ist in Abbildung [[#fig:EvalMetric_1|49]] zu sehen.

<div id="fig:EvalMetric_1" class="figure">

[[Datei:EvalMetric_ConfMatrExa.jpg|300px|thumb|center|Abbildung 49: Eine Beispiel-Konfusionsmatrix für ein Klassifizierungsmodell mit 3 Klassen.]] 

</div>

Die Metriken Precision und Recall wurden ursprünglich für binäre Klassifizierungsmodelle eingeführt, ihre Verwendung kann jedoch auf Mehrklassenfälle (multiclass case) ausgeweitet werden. Daher werden sie zunächst für binäre Klassifizierungsmodelle definiert und erläutert.

In binärer Klassifizierungsaufgabe mit positiven und negativen Klassen kann das Ergebnis der Klassifizierungsaufgabe in einen von vier Fällen eingeteilt werden: richtig/falsch (correctly/incorrectly) klassifizierte Beispiele, die zur positiven/negativen Klasse (positive/negative class) gehören. Die Vorhersage ist true positive (TP), wenn ein positives Beispiel richtig klassifiziert wird, wie z. B. das Vorhandensein einer Krankheit. Eine false negative (FN) Vorhersage tritt auf, wenn ein positives Beispiel vom Modell als zur negativen Klasse gehörend klassifiziert wird. Ebenso tritt eine true negative (TN) Vorhersage auf, wenn ein negatives Beispiel richtig klassifiziert wird. Schließlich ist die Vorhersage false positive (FP), wenn ein negatives Beispiel als zur positiven Klasse gehörend klassifiziert wird. Diese Fälle sind in Tabelle [[#tab:poss_predictions|5]] zusammengefasst.

<div class="center">

<div id="tab:poss_predictions">

{| class="wikitable"
|+ Mögliche Fälle des Ergebnisses der Klassifizierungsaufgabe (=Vorhersage)
|-
! style="text-align: left;"| true <math display="inline">\backslash</math> predicted
! style="text-align: center;"| positive
! style="text-align: center;"| negative
|-
| style="text-align: left;"| positive
| style="text-align: center;"| true positive (TP)
| style="text-align: center;"| false negative (FN)
|-
| style="text-align: left;"| negative
| style="text-align: center;"| false positive (FP)
| style="text-align: center;"| true negative (TN)
|}

</div>

</div>
Für den Fall der binären Klassifizierung kann die Accuracy alternativ wie folgt definiert werden: <math display="block">\mathrm{Accuracy} = \frac{TP+TN}{TP+TN+FP+FN}.</math>

Die Begriffe TP, FN, TN und FP werden auch verwendet, um die Anzahl der entsprechenden Fälle zu bezeichnen, z. B. bezeichnet TP auch die Anzahl der echten positiven Ergebnisse.

Precision ist das Verhältnis der richtig klassifizierten positiven Beispiele zur Gesamtzahl der als positiv klassifizierten Beispiele:

<math display="block">\mathrm{Precision} = \frac{TP}{TP+FP}.</math>

Im Gegensatz dazu bezeichnet der Recall das Verhältnis der richtig klassifizierten Positivbeispiele zur Gesamtzahl der Positivbeispiele: <math display="block">\mathrm{Recall} = \frac{TP}{TP+FN}.</math>

In einer Multi-Class-Setting werden die Metriken Precision und Recall zunächst für jede Klasse einzeln berechnet und dann gemittelt. Auf diese Weise quantifizieren sie die Gesamtklassifizierungsleistung (overall classification performance).

Die Verwendung der verschiedenen Metriken ist in der Tabelle [[#tab:use_metrics|6]] zusammengefasst

<div class="center">

<div id="tab:use_metrics">

{| class="wikitable"
|+ Die Verwendung der verschiedenen Metriken.
|-
! style="text-align: left;"| Bewertungsmetrik
! style="text-align: center;"| Wann verwenden?
|-
| style="text-align: left;"| Accuracy
| style="text-align: center;"| Bei Klassifizierungsproblemen
|-
| style="text-align: left;"|
| style="text-align: center;"| mit ausgeglichenen Klassen
|-
| style="text-align: left;"| Precision
| style="text-align: center;"| Wenn es wichtig ist, sich der positiven Vorhersage
|-
| style="text-align: left;"|
| style="text-align: center;"| sicher zu sein, um negative Konsequenzen zu vermeiden,
|-
| style="text-align: left;"|
| style="text-align: center;"| wie z.B. im Falle einer Verringerung des Kreditlimits,
|-
| style="text-align: left;"|
| style="text-align: center;"| um Unzufriedenheit beim Kunden zu vermeiden.
|-
| style="text-align: left;"| Recall
| style="text-align: center;"| Wenn es wichtig ist, positive Ereignisse mit
|-
| style="text-align: left;"|
| style="text-align: center;"| geringer Wahrscheinlichkeit zu erfassen, wie z.B. um
|-
| style="text-align: left;"|
| style="text-align: center;"| vorherzusagen ob eine Person krank ist oder nicht.
|}

</div>

</div>

=== Evaluation metrics for regression ===

Die am häufigsten verwendeten Metriken, die zur Bewertung von Regressionsmodellen verwendet werden, sind hier aufgeführt.

* Mean Squared Error - MSE (Mittlerer quadrierter Fehler),
* Mean Absolute Error - MAE (Mittlerer absoluter Fehler),

Der Mean Squared Error (MSE) ist eine der grundlegenden Statistiken zur Bewertung der Qualität eines Regressionsmodells. Es handelt sich um den Durchschnitt der Quadrate der Differenz zwischen den tatsächlichen und den vorhergesagten Werten. Mit anderen Worten:

<math display="block">\mathrm{MSE} = \frac{1}{K} \sum_{k} (\hat{y}_k - y_k)^2.</math> Je kleiner der MSE, desto besser passt das Regressionsmodell zu den tatsächlichen Werten.

Der Mean Absolute Error (MAE) ist die durchschnittliche absolute Differenz zwischen den tatsächlichen und den vorhergesagten Werten. <math display="block">\mathrm{MAE} = \frac{1}{K}\sum_{k}|y_k - \hat{y}_k|</math> Eine schöne Eigenschaft des MAE ist, dass er weniger wahrscheinlich von Extremwerten beeinflusst wird. Er ist ein gängiges Maß, das in der Zeitreihenanalyse (time series analysis) als Prognosefehler (forecast error) verwendet wird.


== Verbesserungen und Anpassungen von KI-Modellen ==

Die Konstruktion eines KI-Modells ist keine triviale Aufgabe. Die häufigsten Probleme sind die folgenden.

# Keine oder langsame Konvergenz während des Training.
# Unzureichende Leistung, z. B.
#* zu niedrige Accuracy oder
#* gestreute (nicht diagonal zentriert) Konfusionsmatrix.

Diese Probleme erfordern Verbesserungen bzw. Anpassungen am KI-Modell. Nachfolgend werden die häufigsten Ursachen für keine oder langsame Konvergenz während des Trainings sowie einige mögliche Lösungsansätze für sie aufgelistet.

* Nicht optimale Stopping Kriterium oder leistungsswäche Hardware. In dem Fall können die folgenden Anpassungen helfen.
** Einsetzen von Kriterium des „Early Stopping“.
** Einsetsen von leistungsstärkere Hardware (einschließlich Prozessor, 
RAM und Grafikkarte).
* Unzureichende Optimierungsverfahren. Bei Verwendung einer unzureichenden Optimierungsmethode muss die potenziell beste Optimierungsmethode auf Grundlage früherer Erfahrungen mit Aufgaben in ähnlichen Fachgebieten ausgewählt werden. Diese Auswahl erfodert Erfahrung mit KI-Modelle und tiefes Verständnis der Aufgabe.
* Unzureichende Initialisierung der Parameter. Dies kann durch Ändern oder Anpassen der (heuristischen) Initialisierungsstrategie verbessert werden.
* Kein richtige Hyperparameter-Einstellungen (einschliesslich der Parameter von der verwendeten Optimierungsalgorithmus). Dieses Problem kann durch Ausprobieren mehrerer Hyperparameter-Einstellungen (einschliesslich Minibatch- Größe) oder Anwenden von Regularizationstechniken gelöst werden.
* „Vanishing Gradient Problem“ (in DL mit Anzahl von Hidden Layers in der Größenordnung von 100s). Dies ist ein bekanntes und gut eingegrenztes Problem, welches durch die Verwendung eines etablierten Ansatzes, der zum KI-Modell passt, vermieden werden. (Etablierte Ansätze befinden sich unter [https://en.wikipedia.org/wiki/Vanishing_gradient_problem Vanishing_gradient_problem])

Eine unvollständige Liste möglicher Ursachen für unzureichende Leistung auf Testdaten und einige mögliche Lösungsansätze für sie sind nachstehend aufgeführt.

* Underfitting. Um Underfitting zu vermeiden, müssen die Größe der Trainingsdaten erhöht werden.
* Overfitting. Es gibt mehrere Techniken um Overfitting zu reduzieren. Einige sind wie folgt aufgelistet.
** Verwenden größerer Trainingsdaten.
** Verwenden von Methoden wie Bootstrap-Aggregation oder Random Forest um die Varianz neben gleichem Bias zum reduzieren.
** Verwenden von Dropout Layer - in CNN Modellen.
* Class Imbalance: die Trainingsdaten sind ungleichmäßig auf die Klassen verteilt. Diese wirkt sich negativ auf die Leistung der CNN-Klassifizierung aus [Son et al.(2022)]. Das Problem von Class Imbalance kann gelöst werden, indem die Größe der Trainingsdaten für jede Klasse ausgeglichen wird. Dies kann auf verschiedene Weise erreicht werden, wie z.B.
** Verwenden zusätzlicher Trainingsbeispiele,
** Zusammenführen von Trainingsdaten aus mehreren Klassen oder
* Nicht optimale Hyperparameter-Einstellungen. Siehe oben beim Ursachen von keiner oder langsamer Konvergenz während des Trainings.
* Nicht optimale Initialisierung der Parameter. Siehe oben beim Ursachen von keiner oder langsamer Konvergenz während des Trainings.
* Inadäquate KI-Modell. Das Design des geegneten KI-Modells erfolgt normalerweisse iterative. Jeder Schritt zur Verbesserung des KI-Modells führt zu einem besseren Verständnis der Aufgabe. Der Design von komplexerer KI-Modell/DL-Architektur efordert ein hohes Maß an Erfahrung mit KI-Modellen/DL-Architekturen.


== Stärken und Schwächen von KI-Modellen ==

KI-Modelle haben wie alle technischen Lösungen Stärken und Schwächen.

Einige der Stärken von KI-Modellen können wie folgt aufgelistet werden.

# Eine ihre größte Stärke ist ihre Generalisierungsfähigkeit. ML-Algorithmen können ihren Aufgaben auch mit unbekannten Eingabebeispielen gut ausführen.
# KI-Modelle sind in der Lage, ihre Leistung für eine bestimmte Aufgabe durch zusätzliche Trainingsdaten zu verbessern.
# Sie können viele Aufgaben realisieren, die auf eine oder Kombination von mehreren der folgenden Intelligenz fordernden Aufgaben zurückgeführt werden können: Regression, Klassifizierung, Representation Learning und optimale Kontrolle.
# Sie haben eine sehr breite Anwendbarkeit: mit KI-Modellen können neue Anwendungen praktisch in allen möglichen Anwendungsbereichen implementiert werden.
# In den meisten Anwendungsfällen sind sie schneller als Menschen.
# Bei einigen Aufgaben sind sie leistungsfähiger (z. B. bei der Genauigkeit von Klassifizierungsaufgaben) als die menschliche Intelligenz.

Nachfolgend befindet sich eine unvollständige Liste der Schwächen von KI-Modellen.

# Enige KI-Modelle (z.B. NNs) sind als Black Box zu sehen, d.h. ihre Arbeitsweise ist nicht gut genug verstanden.
# Alle KI-Modelle machen eventuell Fehler z.B. bei Klassifikationsaufgaben.
# Indem sie potenziell fehlerhafte Ergebnisse produzieren, werfen sie ethische Fragen auf.
# Da sie potenziell fehlerhafte Ergebnisse produzieren, können sie nicht zur Entscheidungsfindung verwendet werden, sondern nur für Assistenzanwendungen.
# KI-Modelle sind nicht universell, der Anwendungsbereich jedes KI-Algorithmus ist spezifisch, d. h. jeder KI-Algorithmus hat einen begrenzten Anwendungsbereich.
# Heutige KI-Modelle können viele Fähigkeiten der menschlichen Intelligenz nicht ausführen (wie Abstraktion, Konzepterstellung, analytisches Denken usw.).

Literatur

2024-09-14T23:25:43Z

SAFFER Zsolt:

Evaluierung und Verbesserung von AI-Modellen

2024-09-14T23:24:40Z

SAFFER Zsolt: Die Seite wurde neu angelegt: „ = Evaluierung und Verbesserung von KI-Modellen = == Evaluierung von Klassifikations- und Regressionsmodellen == === Bewertungsmetriken zur Klassifizierung === Ein Klassifizierungsmodell wird anhand der Testdaten ausgewertet. Die zur Bewertung des Modells am…“

= Evaluierung und Verbesserung von KI-Modellen =


== Evaluierung von Klassifikations- und Regressionsmodellen ==


=== Bewertungsmetriken zur Klassifizierung ===

Ein Klassifizierungsmodell wird anhand der Testdaten ausgewertet. Die zur Bewertung des Modells am häufigsten verwendeten allgemeinen Bewertungsmetriken (evaluation metrics) sind wie folgt aufgeführt:

* Accuracy (Genauigkeit),
* Konfusionsmatrix (confusion matrix),
* Precision und Recall (Präzision und Rückruf),

Die Accuracy ist das Verhältnis der korrekt klassifizierten Beispiele zur Gesamtzahl der Beispiele im Testdaten. Definiert man wahre Beispiele (true examples - TE) und falsche Beispiele (false examples - FE) als Anzahl der korrekt und falsch klassifizierten Beispiele im Testdaten, kann die Accuracy wie folgt angegeben werden:

<math display="block">\mathrm{Accuracy} = \frac{TE}{TE+FE}.</math>

Die Konfusionsmatrix ist eine Metrik zur Visualisierung der Klassifizierungsleistung (classification performance). Die Zeilen der Matrix stellen die wahren Klassen dar und die Spalten zeigen die vorhergesagten Klassen. Das Element (i,j) der Matrix zeigt die Anzahl der Testbeispiele, die zur Klasse i gehören und als Klasse j klassifiziert sind. Die Konfusionsmatrix zeigt also nicht nur die Anzahl der korrekt klassifizierten Beispiele für jede Klasse, sondern auch eine Vorstellung von typischen Fehlklassifizierungen, die das Modell vornimmt. Eine Beispiel-Konfusionsmatrix ist in Abbildung [[#fig:EvalMetric_1|49]] zu sehen.

<div id="fig:EvalMetric_1" class="figure">

[[Datei:EvalMetric_ConfMatrExa.jpg|460px|thumb|center|Abbildung 49: Eine Beispiel-Konfusionsmatrix für ein Klassifizierungsmodell mit 3 Klassen.]] 

</div>

Die Metriken Precision und Recall wurden ursprünglich für binäre Klassifizierungsmodelle eingeführt, ihre Verwendung kann jedoch auf Mehrklassenfälle (multiclass case) ausgeweitet werden. Daher werden sie zunächst für binäre Klassifizierungsmodelle definiert und erläutert.

In binärer Klassifizierungsaufgabe mit positiven und negativen Klassen kann das Ergebnis der Klassifizierungsaufgabe in einen von vier Fällen eingeteilt werden: richtig/falsch (correctly/incorrectly) klassifizierte Beispiele, die zur positiven/negativen Klasse (positive/negative class) gehören. Die Vorhersage ist true positive (TP), wenn ein positives Beispiel richtig klassifiziert wird, wie z. B. das Vorhandensein einer Krankheit. Eine false negative (FN) Vorhersage tritt auf, wenn ein positives Beispiel vom Modell als zur negativen Klasse gehörend klassifiziert wird. Ebenso tritt eine true negative (TN) Vorhersage auf, wenn ein negatives Beispiel richtig klassifiziert wird. Schließlich ist die Vorhersage false positive (FP), wenn ein negatives Beispiel als zur positiven Klasse gehörend klassifiziert wird. Diese Fälle sind in Tabelle [[#tab:poss_predictions|5]] zusammengefasst.

<div class="center">

<div id="tab:poss_predictions">

{| class="wikitable"
|+ Mögliche Fälle des Ergebnisses der Klassifizierungsaufgabe (=Vorhersage)
|-
! style="text-align: left;"| true <math display="inline">\backslash</math> predicted
! style="text-align: center;"| positive
! style="text-align: center;"| negative
|-
| style="text-align: left;"| positive
| style="text-align: center;"| true positive (TP)
| style="text-align: center;"| false negative (FN)
|-
| style="text-align: left;"| negative
| style="text-align: center;"| false positive (FP)
| style="text-align: center;"| true negative (TN)
|}

</div>

</div>
Für den Fall der binären Klassifizierung kann die Accuracy alternativ wie folgt definiert werden: <math display="block">\mathrm{Accuracy} = \frac{TP+TN}{TP+TN+FP+FN}.</math>

Die Begriffe TP, FN, TN und FP werden auch verwendet, um die Anzahl der entsprechenden Fälle zu bezeichnen, z. B. bezeichnet TP auch die Anzahl der echten positiven Ergebnisse.

Precision ist das Verhältnis der richtig klassifizierten positiven Beispiele zur Gesamtzahl der als positiv klassifizierten Beispiele:

<math display="block">\mathrm{Precision} = \frac{TP}{TP+FP}.</math>

Im Gegensatz dazu bezeichnet der Recall das Verhältnis der richtig klassifizierten Positivbeispiele zur Gesamtzahl der Positivbeispiele: <math display="block">\mathrm{Recall} = \frac{TP}{TP+FN}.</math>

In einer Multi-Class-Setting werden die Metriken Precision und Recall zunächst für jede Klasse einzeln berechnet und dann gemittelt. Auf diese Weise quantifizieren sie die Gesamtklassifizierungsleistung (overall classification performance).

Die Verwendung der verschiedenen Metriken ist in der Tabelle [[#tab:use_metrics|6]] zusammengefasst

<div class="center">

<div id="tab:use_metrics">

{| class="wikitable"
|+ Die Verwendung der verschiedenen Metriken.
|-
! style="text-align: left;"| Bewertungsmetrik
! style="text-align: center;"| Wann verwenden?
|-
| style="text-align: left;"| Accuracy
| style="text-align: center;"| Bei Klassifizierungsproblemen
|-
| style="text-align: left;"|
| style="text-align: center;"| mit ausgeglichenen Klassen
|-
| style="text-align: left;"| Precision
| style="text-align: center;"| Wenn es wichtig ist, sich der positiven Vorhersage
|-
| style="text-align: left;"|
| style="text-align: center;"| sicher zu sein, um negative Konsequenzen zu vermeiden,
|-
| style="text-align: left;"|
| style="text-align: center;"| wie z.B. im Falle einer Verringerung des Kreditlimits,
|-
| style="text-align: left;"|
| style="text-align: center;"| um Unzufriedenheit beim Kunden zu vermeiden.
|-
| style="text-align: left;"| Recall
| style="text-align: center;"| Wenn es wichtig ist, positive Ereignisse mit
|-
| style="text-align: left;"|
| style="text-align: center;"| geringer Wahrscheinlichkeit zu erfassen, wie z.B. um
|-
| style="text-align: left;"|
| style="text-align: center;"| vorherzusagen ob eine Person krank ist oder nicht.
|}

</div>

</div>

=== Evaluation metrics for regression ===

Die am häufigsten verwendeten Metriken, die zur Bewertung von Regressionsmodellen verwendet werden, sind hier aufgeführt.

* Mean Squared Error - MSE (Mittlerer quadrierter Fehler),
* Mean Absolute Error - MAE (Mittlerer absoluter Fehler),

Der Mean Squared Error (MSE) ist eine der grundlegenden Statistiken zur Bewertung der Qualität eines Regressionsmodells. Es handelt sich um den Durchschnitt der Quadrate der Differenz zwischen den tatsächlichen und den vorhergesagten Werten. Mit anderen Worten:

<math display="block">\mathrm{MSE} = \frac{1}{K} \sum_{k} (\hat{y}_k - y_k)^2.</math> Je kleiner der MSE, desto besser passt das Regressionsmodell zu den tatsächlichen Werten.

Der Mean Absolute Error (MAE) ist die durchschnittliche absolute Differenz zwischen den tatsächlichen und den vorhergesagten Werten. <math display="block">\mathrm{MAE} = \frac{1}{K}\sum_{k}|y_k - \hat{y}_k|</math> Eine schöne Eigenschaft des MAE ist, dass er weniger wahrscheinlich von Extremwerten beeinflusst wird. Er ist ein gängiges Maß, das in der Zeitreihenanalyse (time series analysis) als Prognosefehler (forecast error) verwendet wird.


== Verbesserungen und Anpassungen von KI-Modellen ==

Die Konstruktion eines KI-Modells ist keine triviale Aufgabe. Die häufigsten Probleme sind die folgenden.

# Keine oder langsame Konvergenz während des Training.
# Unzureichende Leistung, z. B.
#* zu niedrige Accuracy oder
#* gestreute (nicht diagonal zentriert) Konfusionsmatrix.

Diese Probleme erfordern Verbesserungen bzw. Anpassungen am KI-Modell. Nachfolgend werden die häufigsten Ursachen für keine oder langsame Konvergenz während des Trainings sowie einige mögliche Lösungsansätze für sie aufgelistet.

* Nicht optimale Stopping Kriterium oder leistungsswäche Hardware. In dem Fall können die folgenden Anpassungen helfen.
** Einsetzen von Kriterium des „Early Stopping“.
** Einsetsen von leistungsstärkere Hardware (einschließlich Prozessor, 
RAM und Grafikkarte).
* Unzureichende Optimierungsverfahren. Bei Verwendung einer unzureichenden Optimierungsmethode muss die potenziell beste Optimierungsmethode auf Grundlage früherer Erfahrungen mit Aufgaben in ähnlichen Fachgebieten ausgewählt werden. Diese Auswahl erfodert Erfahrung mit KI-Modelle und tiefes Verständnis der Aufgabe.
* Unzureichende Initialisierung der Parameter. Dies kann durch Ändern oder Anpassen der (heuristischen) Initialisierungsstrategie verbessert werden.
* Kein richtige Hyperparameter-Einstellungen (einschliesslich der Parameter von der verwendeten Optimierungsalgorithmus). Dieses Problem kann durch Ausprobieren mehrerer Hyperparameter-Einstellungen (einschliesslich Minibatch- Größe) oder Anwenden von Regularizationstechniken gelöst werden.
* „Vanishing Gradient Problem“ (in DL mit Anzahl von Hidden Layers in der Größenordnung von 100s). Dies ist ein bekanntes und gut eingegrenztes Problem, welches durch die Verwendung eines etablierten Ansatzes, der zum KI-Modell passt, vermieden werden. (Etablierte Ansätze befinden sich unter [https://en.wikipedia.org/wiki/Vanishing_gradient_problem Vanishing_gradient_problem])

Eine unvollständige Liste möglicher Ursachen für unzureichende Leistung auf Testdaten und einige mögliche Lösungsansätze für sie sind nachstehend aufgeführt.

* Underfitting. Um Underfitting zu vermeiden, müssen die Größe der Trainingsdaten erhöht werden.
* Overfitting. Es gibt mehrere Techniken um Overfitting zu reduzieren. Einige sind wie folgt aufgelistet.
** Verwenden größerer Trainingsdaten.
** Verwenden von Methoden wie Bootstrap-Aggregation oder Random Forest um die Varianz neben gleichem Bias zum reduzieren.
** Verwenden von Dropout Layer - in CNN Modellen.
* Class Imbalance: die Trainingsdaten sind ungleichmäßig auf die Klassen verteilt. Diese wirkt sich negativ auf die Leistung der CNN-Klassifizierung aus [Son et al.(2022)]. Das Problem von Class Imbalance kann gelöst werden, indem die Größe der Trainingsdaten für jede Klasse ausgeglichen wird. Dies kann auf verschiedene Weise erreicht werden, wie z.B.
** Verwenden zusätzlicher Trainingsbeispiele,
** Zusammenführen von Trainingsdaten aus mehreren Klassen oder
* Nicht optimale Hyperparameter-Einstellungen. Siehe oben beim Ursachen von keiner oder langsamer Konvergenz während des Trainings.
* Nicht optimale Initialisierung der Parameter. Siehe oben beim Ursachen von keiner oder langsamer Konvergenz während des Trainings.
* Inadäquate KI-Modell. Das Design des geegneten KI-Modells erfolgt normalerweisse iterative. Jeder Schritt zur Verbesserung des KI-Modells führt zu einem besseren Verständnis der Aufgabe. Der Design von komplexerer KI-Modell/DL-Architektur efordert ein hohes Maß an Erfahrung mit KI-Modellen/DL-Architekturen.


== Stärken und Schwächen von KI-Modellen ==

KI-Modelle haben wie alle technischen Lösungen Stärken und Schwächen.

Einige der Stärken von KI-Modellen können wie folgt aufgelistet werden.

# Eine ihre größte Stärke ist ihre Generalisierungsfähigkeit. ML-Algorithmen können ihren Aufgaben auch mit unbekannten Eingabebeispielen gut ausführen.
# KI-Modelle sind in der Lage, ihre Leistung für eine bestimmte Aufgabe durch zusätzliche Trainingsdaten zu verbessern.
# Sie können viele Aufgaben realisieren, die auf eine oder Kombination von mehreren der folgenden Intelligenz fordernden Aufgaben zurückgeführt werden können: Regression, Klassifizierung, Representation Learning und optimale Kontrolle.
# Sie haben eine sehr breite Anwendbarkeit: mit KI-Modellen können neue Anwendungen praktisch in allen möglichen Anwendungsbereichen implementiert werden.
# In den meisten Anwendungsfällen sind sie schneller als Menschen.
# Bei einigen Aufgaben sind sie leistungsfähiger (z. B. bei der Genauigkeit von Klassifizierungsaufgaben) als die menschliche Intelligenz.

Nachfolgend befindet sich eine unvollständige Liste der Schwächen von KI-Modellen.

# Enige KI-Modelle (z.B. NNs) sind als Black Box zu sehen, d.h. ihre Arbeitsweise ist nicht gut genug verstanden.
# Alle KI-Modelle machen eventuell Fehler z.B. bei Klassifikationsaufgaben.
# Indem sie potenziell fehlerhafte Ergebnisse produzieren, werfen sie ethische Fragen auf.
# Da sie potenziell fehlerhafte Ergebnisse produzieren, können sie nicht zur Entscheidungsfindung verwendet werden, sondern nur für Assistenzanwendungen.
# KI-Modelle sind nicht universell, der Anwendungsbereich jedes KI-Algorithmus ist spezifisch, d. h. jeder KI-Algorithmus hat einen begrenzten Anwendungsbereich.
# Heutige KI-Modelle können viele Fähigkeiten der menschlichen Intelligenz nicht ausführen (wie Abstraktion, Konzepterstellung, analytisches Denken usw.).

Reinforcement Learning

2024-09-14T23:20:01Z

SAFFER Zsolt:

= Reinforcement Learning =

Reinforcement Learning - RL (Bestärkendes Lernen oder Verstärkungslernen) ist ein agentenbasierter ML Ansatz. Ein Agent passt seine Aktionen iterativ entsprechend dem Feedback der Umgebung an, um sein Ziel zu erreichen. Dieser Mechanismus kommt in vielen biologischen Systemen vor und ist typisch für Kontrollaufgaben. Dieser auf iterativer Bewertung basierende Mechanismus findet jedoch auch bei vielen anderen Aufgaben aus anderen Anwendungsbereichen, da er ein Optimierungsproblem realisiert.


== Kurze Beschreibung von Reinforcement Learning (RL) ==


=== Problemstellung ===

Die Zeit wird als diskrete Zeit modelliert, d. h. sie verläuft in Zeitschritten (time steps). Der RL-Agent befindet sich zum Zeitpunkt <math display="inline">t</math> in einem Zustand <math display="inline">s_t</math> , wobei <math display="inline">s_t \in \mathcal{S}</math>. Der Agent führt eine Aktion <math display="inline">a_t</math>, <math display="inline">a_t \in \mathcal{A}</math> aus den erlaubten Aktionen im Zustand <math display="inline">s_t</math> aus. Als Reaktion der Umgebung auf diese Aktion erhält der Agent eine Belohnung (reward) <math display="inline">r_t</math>, <math display="inline">r_t \in \mathcal{R}</math> und der Zustand des Agenten ändert sich im nächsten Zeitschritt <math display="inline">t+1</math> zu <math display="inline">s_{t+1}</math> . Der Begriff „Umgebung“ wird im weitesten Sinne verwendet, was bedeutet, dass die Umgebung alles sein kann, was auf die Aktionen eines Agenten reagiert. Das Ziel des RL-Agenten wird durch die Maximierung der akkumulierten (erwarteten) Belohnungen (accumulated expected reward) in der Zukunft modelliert, wobei der Wertverlust der Belohnungen (depreciation of rewards) im Laufe der Zeit berücksichtigt wird. Dies erfolgt auf die in der Wirtschaftswissenschaft übliche Methode durch die Anwendung von Abzinsungsfaktoren (discount factors). Auf diese Weise erreicht der RL-Agent sein Ziel, indem er durch iterative Auswertungen der Reaktionen der Umgebung auf seine Aktionen eine Folge von Aktionen festlegt.

Die Interaktion mit der Umgebung wird durch die Belohnungsfunktion <math display="inline">r(s_t,a_t)</math> und die Zustandsänderungen durch Zustandsübergangswahrscheinlichkeiten 
<math display="inline">p(s_{t+1}|s_t,a_t)</math> beschrieben. Die RL-Literatur hinsichtlich des Zusammenhangs der unmittelbaren Belohnung zur Zeit <math display="inline">t</math> oder <math display="inline">t+1</math> nicht einheitlich ist. Während der gesamten Diskussion von RL übernehmen wir die Assoziation der unmittelbaren Belohnung zum Zeitschritt <math display="inline">t</math>. Somit wird die diskontierte, akkumulierte Belohnung im Zeitschritt <math display="inline">t</math>, <math display="inline">t \in N^+</math> durch

<math display="block">R_t = \sum_{\tau = 0}^{\infty} \gamma^{\tau} r_{t+\tau}</math> ausgedrückt, wobei <math display="inline">\gamma \in (0,1]</math> der Abzinsungsfaktor ist. Das Verhalten des Agenten wird durch die Wahrscheinlichkeiten <math display="inline">p(a|s)</math> für <math display="inline">s \in \mathcal{S}</math> und <math display="inline">a \in \mathcal{A}</math> charakterisiert. Sie beschreiben, welche Aktion mit welcher Wahrscheinlichkeit in jedem Zustand durchgeführt wird. Dies bestimmt auch die vom Agenten befolgte Policy, für die die Notation <math display="inline">\pi</math> verwendet wird. Dann das Ziel des Agenenten kann als ein Optimierungsproblem, wie folgt,

<math display="block">\arg\max_{\pi} E[R_t|s_t, \pi]</math>

formuliert werden, wobei <math display="inline">E[]</math> für die Erwartung steht. Die Erwartung bezieht im obigen Ausdruck auf alle zufälligen Komponenten der bedingten diskontierten, akkumulierten ermäßigten Belohnung, gegeben der Startzustand und die Policy. Basierend auf der obigen Optimierungsformulierung kann das Ziel des Agenten auch darin ausgedrückt werden, die optimale Policy zu finden, die zu der maximal erwarteten diskontierten, akkumulierten zukünftigen Belohnung führt.

Wir haben den RL Ansatz in diskreten Räumen (discrete spaces) erklärt, er kann aber auch auf kontinuierliche Zustands- und Aktionsräume (continuous state and action spaces) erweitert werden.


=== Elemente von RL ===

Die typischen Elemente eines RL Ansatzes sind:

# das Modell (model),
# die Strategy (policy),
# die Wertfunktion (value function) und
# die Aktionswertfunktion (action value function).

Das Modell beschreibt die Umgebungsdynamik und wird durch die Belohnungsfunktion <math display="inline">r(s,a)</math> und die Übergangswahrscheinlichkeiten der Zuständen 
<math display="inline">p(s^{'}|s,a)</math> gegeben. Alternativ kann es in kompakter Form durch die Funktion <math display="inline">p(s^{'},r|s,a)</math> angegeben werden.

Die Policy beschreibt das langfristige Verhalten, das der Agent während seiner Interaktion mit der Umgebung im Laufe der Zeit verfolgt. Im Allgemeinen ist die Policy <math display="inline">\pi</math> eine Abbildung, die jedem Zustand <math display="inline">s \in \mathcal{S}</math> die Wahrscheinlichkeitsverteilung <math display="inline">p(a|s)</math>, <math display="inline">a \in \mathcal{A}</math> zuweist , d. h. die Policy wird durch die Aktionswahrscheinlichkeiten spezifiziert, die die Wahrscheinlichkeit des Ausführens einer Aktion in einem bestimmten Zustand charakterisieren. Im Falle einer deterministischen Policy wird jedem Zustand nur eine Aktion zugewiesen. Für diesen Fall verwenden wir die Funktionsnotation <math display="inline">a = \pi(s)</math> für <math display="inline">a \in \mathcal{A}</math> und <math display="inline">s \in \mathcal{S}</math>.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Wertfunktion'''''

Die (Zustands-)Wertfunktion gibt die erwartete diskontierte, akkumulierte zukünftige Belohnung unter Berücksichtigung des tatsächlichen Zustands und der Policy an. Aufgrund der Erwartung handelt es sich um eine Art Vorhersage der künftig angesammelten Belohnung. Die Wertfunktion hängt vom Ausgangszustand und der angewendeten Policy ab. Diese werden auch in seinen Notationen ausgedrückt: <math display="inline">V_{\pi}(s)</math> oder <math display="inline">V(s)</math>. Basierend auf der obigen Definition kann es formal durch

<math display="block">V_{\pi}(s) = E[R_t|s_t=s, \pi]</math> gegeben sein.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Aktionswertfunktion'''''

In ähnlicher Weise gibt die Aktionswertfunktion die erwartete diskontierte, akkumulierte zukünftige Belohnung an, jedoch neben dem Anfangszustand und der Policy auch als Abhängigkeit von der Anfangsaktion. Es wird mit <math display="inline">Q_{\pi}(s,a)</math> oder einfach <math display="inline">Q(s,a)</math> bezeichnet und ist formal durch

<math display="block">Q_{\pi}(s,a) = E[R_t|s_t=s, a_t=a, \pi]</math> gegeben.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Bellman-Gleichungen'''''

Sowohl die Wertfunktion als auch die Aktionswertfunktion können rekursiv über die möglichen Zustandsübergänge ausgedrückt werden. Diese werden durch die Bellman-Gleichungen wie folgt angegeben

<math display="block">\begin{aligned}
V_{\pi}(s) &= \sum_{a \in \mathcal{A}} p(a|s) \sum_{s^{'} \in \mathcal{S}, r \in \mathcal{R}} p(s^{'},r|s,a) \left(r + \gamma V_{\pi}(s^{'}) \right) \\
&= \sum_{a \in \mathcal{A}} p(a|s) \left(r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V_{\pi}(s^{'}) \right), \\
Q_{\pi}(s,a) &= \sum_{s^{'} \in \mathcal{S}, r \in \mathcal{R}} p(s^{'},r|s,a) \left(r + \gamma \sum_{a^{'} \in \mathcal{A}} p(a^{'}|s^{'}) Q_{\pi}(s^{'}, a^{'}) \right) \\
&= r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) \sum_{a^{'} \in \mathcal{A}} p(a^{'}|s^{'}) Q_{\pi}(s^{'}, a^{'}) .
\end{aligned}</math>

Diese rekursiven Gleichungen können als Zerlegungen (decompositions) betrachtet werden und als Grundlage für Lösungsalgorithmen für RL, wie dynamische Programmierung (dynamic programming) dienen.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Optimale Wertfunktion'''''

Die optimale Wertfunktion ist der maximale Wert, der über alle mögliche Policy erreicht werden kann. Anders ausgedrückt:

<math display="block">V^*(s) = \max_{\pi} V_{\pi}(s).</math>

Auch <math display="inline">V^*(s)</math> kann auf rekursive Weise ausgedrückt werden, was durch <math display="block">\begin{aligned}
V^*(s) &= \max_{a} \sum_{s^{'} \in \mathcal{S}, r \in \mathcal{R}} p(s^{'},r|s,a) \left(r + \gamma V^*(s^{'}) \right) \\
&= \max_{a} \left(r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V^*(s^{'}) \right)
\end{aligned}</math> gegeben werden kann.

Dies ist ebenfalls eine Bellman-Gleichung. Der Ausdruck von <math display="inline">V^*(s)</math> beinhaltet implizit, dass zunächst (im Zustand <math display="inline">s</math>) die beste Aktion ausgeführt wird. Dies liegt daran, dass die gewichtete Summe in <math display="inline">V_{\pi}(s)</math> mit Wahrscheinlichkeitsgewichten <math display="inline">p(a|s)</math> kann als Interpolation interpretiert werden, weil <math display="inline">\sum_{a \in \mathcal{A}} p(a|s) = 1</math>. Daher ist das Maximum der gewichteten Summe der höchste Wert in der Summe mit dem Wahrscheinlichkeitsgewicht <math display="inline">1</math>. Dies bedeutet, dass das Ergreifen der besten Maßnahme zunächst impliziert, dass die resultierende optimale Policy deterministisch ist.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Optimale Aktionswertfunktion'''''

Ebenso ist die optimale Aktionswertfunktion der maximale Aktionswert, der über alle mögliche Startegie erreicht werden kann. Somit ist es durch

<math display="block">Q^*(s,a) = \max_{\pi} Q_{\pi}(s, a)</math> gegeben.

Beobachte, dass <math display="inline">V^*(s)</math> der Wert ist, bei dem zunächst die beste Aktion durchgeführt wurde. Daraus folgt, dass <math display="inline">V^*(s)</math> mit <math display="inline">Q^*(s,a)</math> als <math display="block">V^*(s) = \max_{a} Q^*(s,a) </math> in Beziehung gesetzt werden kann.

Die Bellman-Gleichung für <math display="inline">Q^*(s,a)</math> kann wie folgt angegeben werden: <math display="block">\begin{aligned}
Q^*(s,a) &= \sum_{s^{'} \in \mathcal{S}, r \in \mathcal{R}} p(s^{'},r|s,a) \left(r + \gamma \max_{a^{'}} Q^*(s^{'}, a^{'}) \right) \\
&= r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) \max_{a^{'}} Q^*(s^{'}, a^{'}) .
\end{aligned}</math>

Auch hier wird zunächst die beste Aktion ausgeführt, jetzt im Zustand <math display="inline">s^{'}</math>, da dies der erste Zustand ist, in dem eine Aktion ausgewählt werden muss (die Aktion <math display="inline">a</math> im Zustand <math display="inline">s</math> ist bereits gegeben).

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Optimale Policy'''''

Die optimale (deterministische) Policy <math display="inline">\pi^*(s)</math> kann aus der optimalen Aktionswertfunktion als <math display="block">\pi^*(s) = \arg \max_{a} Q^*(s,a) </math> erhalten werden.

Die optimale Policy kann auch aus der optimalen Wertfunktion berechnet werden, indem zunächst die optimale Aktionswertfunktion aus der optimalen Wertfunktion berechnet wird. Dies führt zu <math display="block">Q^*(s,a) = r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V^*(s^{'}).</math>


== Methodentypen von RL ==

Es gibt zwei Arten von Methoden zur Lösung eines RL Problems:

* Modellbasierte Methoden (model-based methods)
* Modellfreie Methoden (model-free methods)


=== Modellbasierte Methoden ===

Wenn das RL Modell die Markov-Eigenschaft erfüllt, d. h. die zukünftige Entwicklung der Zustände und Aktionen nur vom tatsächlichen Zustand abhängt, kann das RL Problem als Markov Entscheidungsprozess (MDP) formuliert werden.

Wenn der Status des Prozesses nach jedem Intervall der Länge <math display="inline">T</math> zurückgesetzt wird, dann ist das MDP episodisch mit einer Episode der Länge <math display="inline">T</math>. Eine Trajectory (oder Rollout) ist eine Verwirklichung der Abfolge von Zuständen, Aktionen und Belohnungen in einer Episode. In diesem Fall wird die kumulierte ermäßigte Prämie <math display="block">R = \sum_{t = 0}^{T-1} \gamma^{t} r_{t}</math> gegeben. Im nicht-episodischen MDP <math display="inline">T=\infty</math>. In diesem Fall stellt die Einstellung <math display="inline">\gamma < 1</math> die Endlichkeit der diskontierten, akkumulierten Belohnung sicher.

Wenn das Modell gegeben ist, sind die Belohnungsfunktion <math display="inline">r(s,a)</math> und die Übergangswahrscheinlichkeiten <math display="inline">p(s^{'}|s,a)</math> bekannt. Daher kann der rekursive Charakter der Bellman-Gleichungen genutzt werden. Dies ermöglicht die Erstellung von Algorithmen mithilfe dynamischer Programmierung. Die beiden wichtigsten modellbasierten Algorithmen sind

* Value Iteration und
* Policy Iteration.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Value iteration'''''

Die Wertfunktion kann iterativ für alle Zustände aus der Bellman-Gleichung für <math display="inline">Q^*(s,a)</math>, kombiniert mit der Beziehung zwischen <math display="inline">V^*(s)</math> und <math display="inline">Q^*(s,a)</math>, berechnet werden. Dies ist die Basis für den Value Iteration Algorithmus. Der Pseudocode des Algorithmus wird in Algorithm dargestellt.

 
Algorithm Value iteration 
'''—————————————————————————————''' 
Eingabe: 
- die Belohnungsfunktion <math display="inline">r(s,a)</math> für <math display="inline">s \in \mathcal{S}</math> und <math display="inline">a \in \mathcal{A}</math>, 
- die Übergangswahrscheinlichkeiten <math display="inline">p(s^{'}|s,a)</math> für <math display="inline">s, s^{'} \in \mathcal{S}</math> und <math display="inline">a \in \mathcal{A}</math>. 
Ausgabe: die optimale Wertfunktion <math display="inline">V^*(s)</math> für <math display="inline">s \in \mathcal{S}</math>. 
'''—————————————————————————————''' 
1 Initialisierung von <math display="inline">V(s)</math> mit einer beliebigen nicht negativen Funktion 
2 Wenn das Stoppkriterium NICHT erfüllt ist 
3 for <math display="inline">s \in \mathcal{S}</math> 
4 for <math display="inline">a \in \mathcal{A}</math> 
5 <math display="inline">Q(s,a) = r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V(s^{'})</math> 
6 end 
7 <math display="inline">V(s^{'})= \max_{a^{'}} Q(s^{'}, a^{'})</math> 
8 end 
9 end 
'''—————————————————————————————''' 
Es kann gezeigt werden, dass der Algorithmus immer gegen <math display="inline">V^*(s)</math> 
([Bellman(1957)], [Bertsekas(1987)]) konvergiert. Die optimale Policy kann aus dem berechneten <math display="inline">Q^*(s,a)</math> bestimmt werden. Dies ist ein Greedy Algorithmus, da <math display="inline">V^*(s)</math> in jeder Iteration basierend auf der besten Aktion in jedem Zustand bestimmt wird. Allgemeiner gesagt ist ein Algorithmus Greedy, wenn in jedem Iterationsschritt die Eingabe für die nächste Iteration als die (in gewisser Weise) beste Ausgabe des tatsächlichen Iterationsschritts bestimmt wird. Ein wirksames Stoppkriterium besteht darin, zu iterieren, bis die maximale Differenz zwischen zwei aufeinanderfolgenden Wertfunktionen kleiner als ein vorgeschriebener kleiner <math display="inline">\epsilon</math>-Wert ist.

Die numerische Komplexität des Algorithmus beträgt <math display="inline">\mathcal{O}(|\mathcal{S}|^2 |\mathcal{A}| I)</math>, wobei <math display="inline">I</math> die Anzahl der erforderlichen Iterationen ist.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Policy Iteration'''''

Bei der Value Iteration wird die optimale Policy indirekt aus der optimalen Wertfunktion ermittelt. Im Policy Iteration Algorithmus wird die Policy direkt in jedem Iterationsschritt berechnet. Die iterative Berechnung der Policy kann direkt erfolgen, indem eine Gleichung verwendet wird, die wiederum aus der Kombination der Bellman-Gleichung für <math display="inline">Q^*(s,a)</math> mit der Beziehung zwischen <math display="inline">V^*(s)</math> und <math display="inline">Q^*(s,a)</math> erhalten wird. Dies führt zu

<math display="block">\pi^*(s) = \arg \max_{a} \left(r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V_{\pi^*}^*(s^{'}) \right).</math>

Die rekursive Berechnung der nächsten Policy <math display="inline">\pi^{'}</math> basierend auf der obigen Gleichung erfordert die Berechnung von <math display="inline">V_{\pi}(s^{'})</math> für jedes <math display="inline">s^{'} \in \mathcal {S}</math> aus der tatsächlichen Policy <math display="inline">\pi(s)</math>. Dies kann erreicht werden, indem die Policy <math display="inline">\pi</math> auf die Bellman-Gleichungen der Wertfunktion angewendet und für die Werte <math display="inline">V_{\pi}(s^{'})</math> gelöst wird. Sie bilden ein lineares Gleichungssystem, da sie keine Maximaloperation beinhalten. Das Zusammenfügen all dieser Punkte ergibt den Policy Iteration Algorithmus. Der Pseudocode des Algorithmus wird in Algorithm angezeigt.

 
Algorithm Policy iteration 
'''—————————————————————————————''' 
Eingabe: 
- die Belohnungsfunktion <math display="inline">r(s,a)</math> für <math display="inline">s \in \mathcal{S}</math> und <math display="inline">a \in \mathcal{A}</math>, 
- die Übergangswahrscheinlichkeiten <math display="inline">p(s^{'}|s,a)</math> für <math display="inline">s, s^{'} \in \mathcal{S}</math> und <math display="inline">a \in \mathcal{A}</math>. 
Ausgabe: die optimale Policy <math display="inline">\pi^*(s)</math> für <math display="inline">s \in \mathcal{S}</math>. 
'''—————————————————————————————''' 
1 Auswählen eine beliebige Policy <math display="inline">\pi^{'}(s)</math> und Einstellen <math display="inline">\pi \neq \pi^{'}</math> 
2 while <math display="inline">\pi^{'} \neq \pi</math> 
3 <math display="inline">\pi = \pi^{'}</math> 
4 Berechnen <math display="inline">V_{\pi}(s^{'})</math> aus der Policy <math display="inline">\pi</math>, durch Lösung eines linearen Gleichungssystems lösen 
<math display="inline">\mathrm{\ \ \ \ \ \ }</math> <math display="inline">V_{\pi}(s) = \left(r(s,\pi(s)) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V_{\pi}(s^{'}) \right)</math> 
5 Aktualisieren die Policy als 
<math display="inline">\mathrm{\ \ \ \ \ \ }</math> <math display="inline">\pi^{'}(s) = \arg \max_{a} \left(r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V_{\pi}(s^{'})\right)</math> for every <math display="inline">s \in \mathcal{S}</math> 
6 end 
'''—————————————————————————————''' 
Das Aktualisieren der Policy bedeutet, die beste erste Aktion anstelle der zuvor von der Policy verwendeten <math display="inline">\pi(s)</math> zu bestimmen. Wenn sie unterschiedlich sind, verbessert die Änderung der ersten Aktion strikt die Wertfunktion (der Wert mit der besten Aktion ist aufgrund von max besser als mit der vorherigen Aktion) und damit auch die Policy. Wenn in der Policy keine Aktion geändert werden, ist keine Verbesserung möglich und die Policy ist somit optimal. Die Anzahl der Iterationen ist mit <math display="inline">|\mathcal{S}|</math> höchstens exponentiell, da die Anzahl der verschiedenen Policy <math display="inline">|\mathcal{A}|^{|\mathcal{S}|}</math> beträgt. Die Anzahl der Operationen ist jedoch pseudopolynomiell.


=== Modellfreie Methoden ===

Wenn kein MDP vorhanden ist, da die Zustände nicht vollständig beobachtbar (fully observable) sind, können in einigen Fällen andere Modelle etabliert werden. Bei MDP stellt die Markov-Eigenschaft sicher, dass die Zustände vollständig beobachtbar sind. Dies ist jedoch nicht immer realistisch. Wenn die Zustände nicht vollständig beobachtbar sind, dann können in einigen Fällen die teilweise beobachtbaren MDPs (partially observable MDPs - POMDPs) ermittelt werden, die die Verallgemeinerung der MDPs darstellen.

Wenn kein Modell vorhanden ist oder das Modell nicht bekannt ist, können modellfreie Methoden verwendet werden. Sie funktionieren auch, wenn es ein MDP-Modell oder ein anderes Modell als MDP, die teilweise beobachtbaren MDPs oder das Multiarmed-Bandit-Modell vorhanden ist.

Zu den wichtigsten modellfreien Algorithmen gehören:

* Temporal Difference (TD) Learning + Bootstrapping
* Q-Learning (einschließlich SARSA)
* Function approximation (Funktionsnäherung)
* Policy Based Methoden (Policy-basierte Methoden) oder Policy Optimization

Weitere Einzelheiten zu modellfreien RL-Methoden können in [Li(2018)] gefunden werden.

Reinforcement Learning

2024-09-14T23:15:15Z

SAFFER Zsolt: Die Seite wurde neu angelegt: „ = Reinforcement Learning = Reinforcement Learning - RL (Bestärkendes Lernen oder Verstärkungslernen) ist ein agentenbasierter ML Ansatz. Ein Agent passt seine Aktionen iterativ entsprechend dem Feedback der Umgebung an, um sein Ziel zu erreichen. Dieser Mechanismus kommt in vielen biologischen Systemen vor und ist typisch für Kontrollaufgaben. Dieser auf iterativer Bewertung basierende Mechanismus findet jedoc…“

= Reinforcement Learning =

Reinforcement Learning - RL (Bestärkendes Lernen oder Verstärkungslernen) ist ein agentenbasierter ML Ansatz. Ein Agent passt seine Aktionen iterativ entsprechend dem Feedback der Umgebung an, um sein Ziel zu erreichen. Dieser Mechanismus kommt in vielen biologischen Systemen vor und ist typisch für Kontrollaufgaben. Dieser auf iterativer Bewertung basierende Mechanismus findet jedoch auch bei vielen anderen Aufgaben aus anderen Anwendungsbereichen, da er ein Optimierungsproblem realisiert.


== Kurze Beschreibung von Reinforcement Learning (RL) ==


=== Problemstellung ===

Die Zeit wird als diskrete Zeit modelliert, d. h. sie verläuft in Zeitschritten (time steps). Der RL-Agent befindet sich zum Zeitpunkt <math display="inline">t</math> in einem Zustand <math display="inline">s_t</math> , wobei <math display="inline">s_t \in \mathcal{S}</math>. Der Agent führt eine Aktion <math display="inline">a_t</math>, <math display="inline">a_t \in \mathcal{A}</math> aus den erlaubten Aktionen im Zustand <math display="inline">s_t</math> aus. Als Reaktion der Umgebung auf diese Aktion erhält der Agent eine Belohnung (reward) <math display="inline">r_t</math>, <math display="inline">r_t \in \mathcal{R}</math> und der Zustand des Agenten ändert sich im nächsten Zeitschritt <math display="inline">t+1</math> zu <math display="inline">s_{t+1}</math> . Der Begriff „Umgebung“ wird im weitesten Sinne verwendet, was bedeutet, dass die Umgebung alles sein kann, was auf die Aktionen eines Agenten reagiert. Das Ziel des RL-Agenten wird durch die Maximierung der akkumulierten (erwarteten) Belohnungen (accumulated expected reward) in der Zukunft modelliert, wobei der Wertverlust der Belohnungen (depreciation of rewards) im Laufe der Zeit berücksichtigt wird. Dies erfolgt auf die in der Wirtschaftswissenschaft übliche Methode durch die Anwendung von Abzinsungsfaktoren (discount factors). Auf diese Weise erreicht der RL-Agent sein Ziel, indem er durch iterative Auswertungen der Reaktionen der Umgebung auf seine Aktionen eine Folge von Aktionen festlegt.

Die Interaktion mit der Umgebung wird durch die Belohnungsfunktion <math display="inline">r(s_t,a_t)</math> und die Zustandsänderungen durch Zustandsübergangswahrscheinlichkeiten 
<math display="inline">p(s_{t+1}|s_t,a_t)</math> beschrieben. Die RL-Literatur hinsichtlich des Zusammenhangs der unmittelbaren Belohnung zur Zeit <math display="inline">t</math> oder <math display="inline">t+1</math> nicht einheitlich ist. Während der gesamten Diskussion von RL übernehmen wir die Assoziation der unmittelbaren Belohnung zum Zeitschritt <math display="inline">t</math>. Somit wird die diskontierte, akkumulierte Belohnung im Zeitschritt <math display="inline">t</math>, <math display="inline">t \in N^+</math> durch

<math display="block">R_t = \sum_{\tau = 0}^{\infty} \gamma^{\tau} r_{t+\tau}</math> ausgedrückt, wobei <math display="inline">\gamma \in (0,1]</math> der Abzinsungsfaktor ist. Das Verhalten des Agenten wird durch die Wahrscheinlichkeiten <math display="inline">p(a|s)</math> für <math display="inline">s \in \mathcal{S}</math> und <math display="inline">a \in \mathcal{A}</math> charakterisiert. Sie beschreiben, welche Aktion mit welcher Wahrscheinlichkeit in jedem Zustand durchgeführt wird. Dies bestimmt auch die vom Agenten befolgte Policy, für die die Notation <math display="inline">\pi</math> verwendet wird. Dann das Ziel des Agenenten kann als ein Optimierungsproblem, wie folgt,

<math display="block">\arg\max_{\pi} E[R_t|s_t, \pi]</math>

formuliert werden, wobei <math display="inline">E[]</math> für die Erwartung steht. Die Erwartung bezieht im obigen Ausdruck auf alle zufälligen Komponenten der bedingten diskontierten, akkumulierten ermäßigten Belohnung, gegeben der Startzustand und die Policy. Basierend auf der obigen Optimierungsformulierung kann das Ziel des Agenten auch darin ausgedrückt werden, die optimale Policy zu finden, die zu der maximal erwarteten diskontierten, akkumulierten zukünftigen Belohnung führt.

Wir haben den RL Ansatz in diskreten Räumen (discrete spaces) erklärt, er kann aber auch auf kontinuierliche Zustands- und Aktionsräume (continuous state and action spaces) erweitert werden.


=== Elemente von RL ===

Die typischen Elemente eines RL Ansatzes sind:

# das Modell (model),
# die Strategy (policy),
# die Wertfunktion (value function) und
# die Aktionswertfunktion (action value function).

Das Modell beschreibt die Umgebungsdynamik und wird durch die Belohnungsfunktion <math display="inline">r(s,a)</math> und die Übergangswahrscheinlichkeiten der Zuständen 
<math display="inline">p(s^{'}|s,a)</math> gegeben. Alternativ kann es in kompakter Form durch die Funktion <math display="inline">p(s^{'},r|s,a)</math> angegeben werden.

Die Policy beschreibt das langfristige Verhalten, das der Agent während seiner Interaktion mit der Umgebung im Laufe der Zeit verfolgt. Im Allgemeinen ist die Policy <math display="inline">\pi</math> eine Abbildung, die jedem Zustand <math display="inline">s \in \mathcal{S}</math> die Wahrscheinlichkeitsverteilung <math display="inline">p(a|s)</math>, <math display="inline">a \in \mathcal{A}</math> zuweist , d. h. die Policy wird durch die Aktionswahrscheinlichkeiten spezifiziert, die die Wahrscheinlichkeit des Ausführens einer Aktion in einem bestimmten Zustand charakterisieren. Im Falle einer deterministischen Policy wird jedem Zustand nur eine Aktion zugewiesen. Für diesen Fall verwenden wir die Funktionsnotation <math display="inline">a = \pi(s)</math> für <math display="inline">a \in \mathcal{A}</math> und <math display="inline">s \in \mathcal{S}</math>.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Wertfunktion'''''

Die (Zustands-)Wertfunktion gibt die erwartete diskontierte, akkumulierte zukünftige Belohnung unter Berücksichtigung des tatsächlichen Zustands und der Policy an. Aufgrund der Erwartung handelt es sich um eine Art Vorhersage der künftig angesammelten Belohnung. Die Wertfunktion hängt vom Ausgangszustand und der angewendeten Policy ab. Diese werden auch in seinen Notationen ausgedrückt: <math display="inline">V_{\pi}(s)</math> oder <math display="inline">V(s)</math>. Basierend auf der obigen Definition kann es formal durch

<math display="block">V_{\pi}(s) = E[R_t|s_t=s, \pi]</math> gegeben sein.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Aktionswertfunktion'''''

In ähnlicher Weise gibt die Aktionswertfunktion die erwartete diskontierte, akkumulierte zukünftige Belohnung an, jedoch neben dem Anfangszustand und der Policy auch als Abhängigkeit von der Anfangsaktion. Es wird mit <math display="inline">Q_{\pi}(s,a)</math> oder einfach <math display="inline">Q(s,a)</math> bezeichnet und ist formal durch

<math display="block">Q_{\pi}(s,a) = E[R_t|s_t=s, a_t=a, \pi]</math> gegeben.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Bellman-Gleichungen'''''

Sowohl die Wertfunktion als auch die Aktionswertfunktion können rekursiv über die möglichen Zustandsübergänge ausgedrückt werden. Diese werden durch die Bellman-Gleichungen wie folgt angegeben

<math display="block">\begin{aligned}
V_{\pi}(s) &= \sum_{a \in \mathcal{A}} p(a|s) \sum_{s^{'} \in \mathcal{S}, r \in \mathcal{R}} p(s^{'},r|s,a) \left(r + \gamma V_{\pi}(s^{'}) \right) \\
&= \sum_{a \in \mathcal{A}} p(a|s) \left(r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V_{\pi}(s^{'}) \right), \\
Q_{\pi}(s,a) &= \sum_{s^{'} \in \mathcal{S}, r \in \mathcal{R}} p(s^{'},r|s,a) \left(r + \gamma \sum_{a^{'} \in \mathcal{A}} p(a^{'}|s^{'}) Q_{\pi}(s^{'}, a^{'}) \right) \\
&= r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) \sum_{a^{'} \in \mathcal{A}} p(a^{'}|s^{'}) Q_{\pi}(s^{'}, a^{'}) .
\end{aligned}</math>

Diese rekursiven Gleichungen können als Zerlegungen (decompositions) betrachtet werden und als Grundlage für Lösungsalgorithmen für RL, wie dynamische Programmierung (dynamic programming) dienen.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Optimale Wertfunktion'''''

Die optimale Wertfunktion ist der maximale Wert, der über alle mögliche Policy erreicht werden kann. Anders ausgedrückt:

<math display="block">V^*(s) = \max_{\pi} V_{\pi}(s).</math>

Auch <math display="inline">V^*(s)</math> kann auf rekursive Weise ausgedrückt werden, was durch <math display="block">\begin{aligned}
V^*(s) &= \max_{a} \sum_{s^{'} \in \mathcal{S}, r \in \mathcal{R}} p(s^{'},r|s,a) \left(r + \gamma V^*(s^{'}) \right) \\
&= \max_{a} \left(r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V^*(s^{'}) \right)
\end{aligned}</math> gegeben werden kann.

Dies ist ebenfalls eine Bellman-Gleichung. Der Ausdruck von <math display="inline">V^*(s)</math> beinhaltet implizit, dass zunächst (im Zustand <math display="inline">s</math>) die beste Aktion ausgeführt wird. Dies liegt daran, dass die gewichtete Summe in <math display="inline">V_{\pi}(s)</math> mit Wahrscheinlichkeitsgewichten <math display="inline">p(a|s)</math> kann als Interpolation interpretiert werden, weil <math display="inline">\sum_{a \in \mathcal{A}} p(a|s) = 1</math>. Daher ist das Maximum der gewichteten Summe der höchste Wert in der Summe mit dem Wahrscheinlichkeitsgewicht <math display="inline">1</math>. Dies bedeutet, dass das Ergreifen der besten Maßnahme zunächst impliziert, dass die resultierende optimale Policy deterministisch ist.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Optimale Aktionswertfunktion'''''

Ebenso ist die optimale Aktionswertfunktion der maximale Aktionswert, der über alle mögliche Startegie erreicht werden kann. Somit ist es durch

<math display="block">Q^*(s,a) = \max_{\pi} Q_{\pi}(s, a)</math> gegeben.

Beobachte, dass <math display="inline">V^*(s)</math> der Wert ist, bei dem zunächst die beste Aktion durchgeführt wurde. Daraus folgt, dass <math display="inline">V^*(s)</math> mit <math display="inline">Q^*(s,a)</math> als <math display="block">V^*(s) = \max_{a} Q^*(s,a) \label{opV_opQ}</math> in Beziehung gesetzt werden kann.

Die Bellman-Gleichung für <math display="inline">Q^*(s,a)</math> kann wie folgt angegeben werden: <math display="block">\begin{aligned}
Q^*(s,a) &= \sum_{s^{'} \in \mathcal{S}, r \in \mathcal{R}} p(s^{'},r|s,a) \left(r + \gamma \max_{a^{'}} Q^*(s^{'}, a^{'}) \right) \\
&= r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) \max_{a^{'}} Q^*(s^{'}, a^{'}) .
\end{aligned}</math>

Auch hier wird zunächst die beste Aktion ausgeführt, jetzt im Zustand <math display="inline">s^{'}</math>, da dies der erste Zustand ist, in dem eine Aktion ausgewählt werden muss (die Aktion <math display="inline">a</math> im Zustand <math display="inline">s</math> ist bereits gegeben).

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Optimale Policy'''''

Die optimale (deterministische) Policy <math display="inline">\pi^*(s)</math> kann aus der optimalen Aktionswertfunktion als <math display="block">\pi^*(s) = \arg \max_{a} Q^*(s,a) \label{opPol_opQ}</math> erhalten werden.

Die optimale Policy kann auch aus der optimalen Wertfunktion berechnet werden, indem zunächst die optimale Aktionswertfunktion aus der optimalen Wertfunktion berechnet wird. Dies führt zu <math display="block">Q^*(s,a) = r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V^*(s^{'}).</math>


== Methodentypen von RL ==

Es gibt zwei Arten von Methoden zur Lösung eines RL Problems:

* Modellbasierte Methoden (model-based methods)
* Modellfreie Methoden (model-free methods)


=== Modellbasierte Methoden ===

Wenn das RL Modell die Markov-Eigenschaft erfüllt, d. h. die zukünftige Entwicklung der Zustände und Aktionen nur vom tatsächlichen Zustand abhängt, kann das RL Problem als Markov Entscheidungsprozess (MDP) formuliert werden.

Wenn der Status des Prozesses nach jedem Intervall der Länge <math display="inline">T</math> zurückgesetzt wird, dann ist das MDP episodisch mit einer Episode der Länge <math display="inline">T</math>. Eine Trajectory (oder Rollout) ist eine Verwirklichung der Abfolge von Zuständen, Aktionen und Belohnungen in einer Episode. In diesem Fall wird die kumulierte ermäßigte Prämie <math display="block">R = \sum_{t = 0}^{T-1} \gamma^{t} r_{t}</math> gegeben. Im nicht-episodischen MDP <math display="inline">T=\infty</math>. In diesem Fall stellt die Einstellung <math display="inline">\gamma < 1</math> die Endlichkeit der diskontierten, akkumulierten Belohnung sicher.

Wenn das Modell gegeben ist, sind die Belohnungsfunktion <math display="inline">r(s,a)</math> und die Übergangswahrscheinlichkeiten <math display="inline">p(s^{'}|s,a)</math> bekannt. Daher kann der rekursive Charakter der Bellman-Gleichungen genutzt werden. Dies ermöglicht die Erstellung von Algorithmen mithilfe dynamischer Programmierung. Die beiden wichtigsten modellbasierten Algorithmen sind

* Value Iteration und
* Policy Iteration.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Value iteration'''''

Die Wertfunktion kann iterativ für alle Zustände aus der Bellman-Gleichung für <math display="inline">Q^*(s,a)</math>, kombiniert mit der Beziehung zwischen <math display="inline">V^*(s)</math> und <math display="inline">Q^*(s,a)</math>, berechnet werden. Dies ist die Basis für den Value Iteration Algorithmus. Der Pseudocode des Algorithmus wird in Algorithm dargestellt.

 
Algorithm Value iteration 
'''—————————————————————————————''' 
Eingabe: 
- die Belohnungsfunktion <math display="inline">r(s,a)</math> für <math display="inline">s \in \mathcal{S}</math> und <math display="inline">a \in \mathcal{A}</math>, 
- die Übergangswahrscheinlichkeiten <math display="inline">p(s^{'}|s,a)</math> für <math display="inline">s, s^{'} \in \mathcal{S}</math> und <math display="inline">a \in \mathcal{A}</math>. 
Ausgabe: die optimale Wertfunktion <math display="inline">V^*(s)</math> für <math display="inline">s \in \mathcal{S}</math>. 
'''—————————————————————————————''' 
1 Initialisierung von <math display="inline">V(s)</math> mit einer beliebigen nicht negativen Funktion 
2 Wenn das Stoppkriterium NICHT erfüllt ist 
3 for <math display="inline">s \in \mathcal{S}</math> 
4 for <math display="inline">a \in \mathcal{A}</math> 
5 <math display="inline">Q(s,a) = r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V(s^{'})</math> 
6 end 
7 <math display="inline">V(s^{'})= \max_{a^{'}} Q(s^{'}, a^{'})</math> 
8 end 
9 end 
'''—————————————————————————————''' 
Es kann gezeigt werden, dass der Algorithmus immer gegen <math display="inline">V^*(s)</math> 
([Bellman(1957)], [Bertsekas(1987)]) konvergiert. Die optimale Policy kann aus dem berechneten <math display="inline">Q^*(s,a)</math> bestimmt werden. Dies ist ein Greedy Algorithmus, da <math display="inline">V^*(s)</math> in jeder Iteration basierend auf der besten Aktion in jedem Zustand bestimmt wird. Allgemeiner gesagt ist ein Algorithmus Greedy, wenn in jedem Iterationsschritt die Eingabe für die nächste Iteration als die (in gewisser Weise) beste Ausgabe des tatsächlichen Iterationsschritts bestimmt wird. Ein wirksames Stoppkriterium besteht darin, zu iterieren, bis die maximale Differenz zwischen zwei aufeinanderfolgenden Wertfunktionen kleiner als ein vorgeschriebener kleiner <math display="inline">\epsilon</math>-Wert ist.

Die numerische Komplexität des Algorithmus beträgt <math display="inline">\mathcal{O}(|\mathcal{S}|^2 |\mathcal{A}| I)</math>, wobei <math display="inline">I</math> die Anzahl der erforderlichen Iterationen ist.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Policy Iteration'''''

Bei der Value Iteration wird die optimale Policy indirekt aus der optimalen Wertfunktion ermittelt. Im Policy Iteration Algorithmus wird die Policy direkt in jedem Iterationsschritt berechnet. Die iterative Berechnung der Policy kann direkt erfolgen, indem eine Gleichung verwendet wird, die wiederum aus der Kombination der Bellman-Gleichung für <math display="inline">Q^*(s,a)</math> mit der Beziehung zwischen <math display="inline">V^*(s)</math> und <math display="inline">Q^*(s,a)</math> erhalten wird. Dies führt zu

<math display="block">\pi^*(s) = \arg \max_{a} \left(r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V_{\pi^*}^*(s^{'}) \right).</math>

Die rekursive Berechnung der nächsten Policy <math display="inline">\pi^{'}</math> basierend auf der obigen Gleichung erfordert die Berechnung von <math display="inline">V_{\pi}(s^{'})</math> für jedes <math display="inline">s^{'} \in \mathcal {S}</math> aus der tatsächlichen Policy <math display="inline">\pi(s)</math>. Dies kann erreicht werden, indem die Policy <math display="inline">\pi</math> auf die Bellman-Gleichungen der Wertfunktion angewendet und für die Werte <math display="inline">V_{\pi}(s^{'})</math> gelöst wird. Sie bilden ein lineares Gleichungssystem, da sie keine Maximaloperation beinhalten. Das Zusammenfügen all dieser Punkte ergibt den Policy Iteration Algorithmus. Der Pseudocode des Algorithmus wird in Algorithm angezeigt.

 
Algorithm Policy iteration 
'''—————————————————————————————''' 
Eingabe: 
- die Belohnungsfunktion <math display="inline">r(s,a)</math> für <math display="inline">s \in \mathcal{S}</math> und <math display="inline">a \in \mathcal{A}</math>, 
- die Übergangswahrscheinlichkeiten <math display="inline">p(s^{'}|s,a)</math> für <math display="inline">s, s^{'} \in \mathcal{S}</math> und <math display="inline">a \in \mathcal{A}</math>. 
Ausgabe: die optimale Policy <math display="inline">\pi^*(s)</math> für <math display="inline">s \in \mathcal{S}</math>. 
'''—————————————————————————————''' 
1 Auswählen eine beliebige Policy <math display="inline">\pi^{'}(s)</math> und Einstellen <math display="inline">\pi \neq \pi^{'}</math> 
2 while <math display="inline">\pi^{'} \neq \pi</math> 
3 <math display="inline">\pi = \pi^{'}</math> 
4 Berechnen <math display="inline">V_{\pi}(s^{'})</math> aus der Policy <math display="inline">\pi</math>, durch Lösung eines linearen Gleichungssystems lösen 
<math display="inline">\mathrm{\ \ \ \ \ \ }</math> <math display="inline">V_{\pi}(s) = \left(r(s,\pi(s)) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V_{\pi}(s^{'}) \right)</math> 
5 Aktualisieren die Policy als 
<math display="inline">\mathrm{\ \ \ \ \ \ }</math> <math display="inline">\pi^{'}(s) = \arg \max_{a} \left(r(s,a) + \gamma \sum_{s^{'} \in \mathcal{S}} p(s^{'}|s,a) V_{\pi}(s^{'})\right)</math> for every <math display="inline">s \in \mathcal{S}</math> 
6 end 
'''—————————————————————————————''' 
Das Aktualisieren der Policy bedeutet, die beste erste Aktion anstelle der zuvor von der Policy verwendeten <math display="inline">\pi(s)</math> zu bestimmen. Wenn sie unterschiedlich sind, verbessert die Änderung der ersten Aktion strikt die Wertfunktion (der Wert mit der besten Aktion ist aufgrund von max besser als mit der vorherigen Aktion) und damit auch die Policy. Wenn in der Policy keine Aktion geändert werden, ist keine Verbesserung möglich und die Policy ist somit optimal. Die Anzahl der Iterationen ist mit <math display="inline">|\mathcal{S}|</math> höchstens exponentiell, da die Anzahl der verschiedenen Policy <math display="inline">|\mathcal{A}|^{|\mathcal{S}|}</math> beträgt. Die Anzahl der Operationen ist jedoch pseudopolynomiell.


=== Modellfreie Methoden ===

Wenn kein MDP vorhanden ist, da die Zustände nicht vollständig beobachtbar (fully observable) sind, können in einigen Fällen andere Modelle etabliert werden. Bei MDP stellt die Markov-Eigenschaft sicher, dass die Zustände vollständig beobachtbar sind. Dies ist jedoch nicht immer realistisch. Wenn die Zustände nicht vollständig beobachtbar sind, dann können in einigen Fällen die teilweise beobachtbaren MDPs (partially observable MDPs - POMDPs) ermittelt werden, die die Verallgemeinerung der MDPs darstellen.

Wenn kein Modell vorhanden ist oder das Modell nicht bekannt ist, können modellfreie Methoden verwendet werden. Sie funktionieren auch, wenn es ein MDP-Modell oder ein anderes Modell als MDP, die teilweise beobachtbaren MDPs oder das Multiarmed-Bandit-Modell vorhanden ist.

Zu den wichtigsten modellfreien Algorithmen gehören:

* Temporal Difference (TD) Learning + Bootstrapping
* Q-Learning (einschließlich SARSA)
* Function approximation (Funktionsnäherung)
* Policy Based Methoden (Policy-basierte Methoden) oder Policy Optimization

Weitere Einzelheiten zu modellfreien RL-Methoden können in [Li(2018)] gefunden werden.

Verschiedene Techniken für maschinelles Lernen und Deep Learning

2024-09-14T23:12:00Z

SAFFER Zsolt:

= Verschiedene Techniken für maschinelles Lernen und Deep Learning =


== Support-Vektor-Maschinen ==

Support-Vektor-Maschinen (support vector machines - SVMs) sind moderne Klassifikatoren. In ihrer ursprünglichen Form können sie auf die Klassifizierung mit zwei Klassen angewendet werden (binären Klassifikator - binary classifier). Die gute Klassifizierungsfähigkeit von SVMs basiert auf der Idee, dass eine Erhöhung der Dimensionalität der Eingabedaten eine bessere Trennbarkeit der Klassen ermöglicht. Je höher die Dimension der Projektion der Eingabedaten, desto größer ist die Wahrscheinlichkeit einer besseren Trennfähigkeit der entsprechenden Hyperebenen. Der Name SVM kommt von den Support-Vektoren, den Feature Vektoren des Trainingssatzes, die am Rand der Klassen im hochdimensionalen Raum liegen. Es stellt sich heraus, dass sie die optimale Entscheidungsfläche vollständig bestimmen.

SVMs werden für verschiedene reale Probleme eingesetzt, darunter unter anderem die Erkennung handschriftlicher Zeichen (hand-written character recognition), die Bildklassifizierung, die Klassifizierung von Satellitendaten (satellite data classification) und Klassifizierungsaufgaben in den Biowissenschaften (classification tasks in biological sciences).


=== Lineare SVM mit linear trennbaren Klassen ===

Eine SVM ist linear, wenn ihre Entscheidungsfläche im Raum der Eingabevektoren linear ist, also eine Hyperebene ist. Angenommen, der Eingabedaten ist durch die <math display="inline">L</math>-dimensionalen Vektoren <math display="inline">{\bf x}_1, \ldots, {\bf x}_N</math> und ihre entsprechenden Klassenbezeichnungen <math display="inline">y_1,\ldots, y_N</math> gegeben. Die beste Trennfähigkeit kann durch <math display="inline">L-1</math>-dimensionale Hyperebenen erreicht werden. Die Klassen sind linear trennbar, wenn zwischen den Klassen Hyperebenen liegen. In diesem Unterabschnitt diskutieren wir lineare SVM mit linear trennbaren Klassen.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Optimale Hyperebene als Entscheidungsflächen'''''

Im Allgemeinen gibt es bei linear trennbaren Klassen viele Hyperebenen, die die Klassen trennen können. Ihre Trennfähigkeit hängt jedoch von ihrer Positionierung zu den Klassen der Eingabedaten ab, siehe Abbildung [[#fig:SVM_2|26]].

<div id="fig:SVM_2" class="figure">

[[Datei:SVM_WIPE_1.jpg|460px|thumb|center|Abbildung 26: Abhängigkeit der Trennfähigkeit von Hyperebenen von ihrer Position zu den Klassen der Eingabedaten (Quelle: [https://en.wikipedia.org/wiki/Support_vector_machine Wikipedia_SVM]).]] 

</div>

Intuitiv ergibt die Hyperebene mit dem größten Abstand zu den Klassen die größte Trennungsfähigkeit. Der Abstand einer Hyperebene zu den Klassen entspricht dem Abstand zu ihren nächstgelegenen Punkten. Die Summe der Abstände von einer Hyperebene zu den Klassen wird als Margin bezeichnet. Z. B. in Abbildung [[#fig:SVM_2|26]] H1 trennt die Klassen gar nicht. H2 und H3 schon, aber H2 nur mit einer kleinen Margin. H3 ist die Hyperebene, die die Klassen mit der maximalen Margin trennt.

Tatsächlich kann gezeigt werden, dass die Hyperebene mit dem größten Margin als Entscheidungsfläche die optimale ist, in dem Sinne, dass sie bei der Klassifizierung den geringeren Generalisierungsfehler verursacht. Die optimale Hyperebene wird als Hyperebene mit maximalem Margin bezeichnet.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Optimierungsaufgabe zum Finden der Maximum-Margin Hyperebene'''''

Jede Hyperebene kann durch eine lineare Gleichung in Normalform beschrieben werden als <math display="block">{\bf w}^T {\bf x} + c = 0.</math> Hier ist <math display="inline">{\bf w}</math> ein <math display="inline">N</math>-dimensionaler Normalenvektor, d. h. er ist rechtwinklig zur Hyperebene und die Konstante <math display="inline">c</math> hängt von der Größe von <math display="inline">{\bf w}</math> ab (Multiplikation der obigen Gleichung mit einer beliebigen Konstante <math display="inline">k</math> bleibt die Richtung von <math display="inline">{\bf w}</math> gleich, aber sowohl seine Größe als auch <math display="inline">c</math> ändern sich). Die Projektion eines beliebigen Punktes <math display="inline">{\bf x}</math> als Vektor auf die Richtung von <math display="inline">{\bf w}</math> ist <math display="inline">\frac{{\bf w}^T {\bf x}}{\lVert {\bf w} \rVert}</math>. Andererseits impliziert die Gleichung der Hyperebene, dass für jeden auf der Hyperebene liegenden Punkt <math display="inline">{\bf w}^T {\bf x} = -c</math> gilt. Somit ist die Projektion eines beliebigen Punktes <math display="inline">{\bf x}</math>, der auf der Hyperebene liegt, als Vektor auf die Richtung von <math display="inline">{\bf w}</math> kann durch <math display="block">\frac{-c}{\lVert {\bf w} \rVert}</math> gegeben werden. Wählen wir die Konstante <math display="inline">c</math> in den Gleichungen der an den Klassengrenzen liegenden Hyperebenen als <math display="inline">b-1</math> und <math display="inline">b+1</math>, was für diese Hyperebenen zu den Gleichungen als <math display="block">\begin{aligned}
&{\bf w}^T {\bf x} + b = 1, \\
&{\bf w}^T {\bf x} + b = -1
\end{aligned}</math> führt. Dann entspricht der Margin für eine Hyperebene, die auf halber Strecke zwischen den oben genannten Hyperebenen liegt, <math display="inline">\rho({\bf w},b)</math> dem Abstand zwischen diesen Hyperebenen. Der kann als Differenz der Projektionen jedes auf diesen Hyperebenen liegenden Punktes auf ihren Normalenvektor berechnet werden, der durch <math display="block">\rho({\bf w},b) = \frac{(1-b)}{\lVert {\bf w} \rVert} - \frac{(-b-1)}{\lVert {\bf w} \rVert}= \frac{2}{\lVert {\bf w} \rVert}</math> gegeben ist.

Daraus folgt, dass die Maximierung der Margin gleichwertig mit der Minimierung von <math display="inline">\lVert {\bf w} \rVert^2</math> ist.

Somit beträgt der Abstand zwischen der Hyperebene, die auf halbem Weg zwischen den obigen Hyperebenen liegt, und einer von ihnen <math display="inline">\frac{1}{\lVert {\bf w} \rVert}</math>, was impliziert, dass für die Gleichung der Hyperebene, die auf halbem Weg zwischen die obigen Hyperebenen liegt, <math display="inline">\frac{(1-b)}{\lVert {\bf w} \rVert} - \frac{(-c)}{\lVert {\bf w} \rVert}= \frac{1} {\lVert {\bf w} \rVert}</math> gilt, woraus <math display="inline">c=b</math> und somit ist diese Gleichung durch <math display="block">{\bf w}^T {\bf x} + b = 0</math> gegeben. Diese Hyperebenen und die oben genannten Abstände sind in Abbildung [[#fig:SVM_3|27]] dargestellt.

<div id="fig:SVM_3" class="figure">

[[Datei:SVM_WIPE_3.jpg|460px|thumb|center|Abbildung 27: Hyperebene, die auf halber Strecke zwischen den Klassen liegt, deren Abstände und Margin (Quelle: [https://en.wikipedia.org/wiki/Support_vector_machine Wikipedia_SVM]).]] 

</div>

Wählen wir die Bezeichnungen <math display="inline">y_i=1</math> und <math display="inline">y_i=-1</math> für die erste bzw. zweite Klasse. Dann erfüllen alle Vektoren der Eingabedaten, die zur ersten und zweiten Klasse gehören, jeweils die Ungleichungen <math display="block">\begin{aligned}
&{\bf w}^T {\bf x}_i + b \geq 1, \mathrm{~wenn~} y_i = 1 \mathrm{~and~} \\
&{\bf w}^T {\bf x}_i + b \leq -1. \mathrm{~wenn~} y_i = -1.
\end{aligned}</math>

Diese beiden Ungleichungen können in einer äquivalenten kompakten Form als <math display="block">y_i({\bf w}^T {\bf x}_i + b) \geq 1</math> geschrieben werden. Wenn man all dies zusammenfügt, ergibt sich die Optimierungsaufgabe mit Nebenbedingungen (constrained optimization task) zum Finden der Maximum-Margin Hyperebene als <math display="block">\begin{aligned}
&({\bf w}, b) = \arg \min_{{\bf w}, b} \lVert {\bf w} \rVert^2, ~ \mathrm{~unter~den~Bedingungen~}~ \\
& y_i({\bf w}^T {\bf x}_i + b) \geq 1, ~~i=1,\ldots,N.
\end{aligned}</math>

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Quadratisches Programm (quadratic programming problem) für die Lagrange-Multiplikatoren'''''

Um das Optimierungsproblem mit Nebenbedingungen zu lösen, die Lagrange-Funktion wird konstruiert als <math display="block">L({\bf w}, b, {\boldsymbol{\Lambda}}) = \frac{1}{2} {\bf w}^T{\bf w} - \sum_{i=1}^N \lambda_i \left( y_i ({\bf w}^T {\bf x}_i + b) -1\right),</math>

wobei die Elemente von <math display="inline">{\boldsymbol{\Lambda}}^T =(\lambda_1,\ldots,\lambda_N)</math> aufgrund der Nebenbedingungen die nicht negativen Lagrange-Multiplikatoren sind. Berechnen die ersten Ableitungen nach <math display="inline">{\bf w}</math> und <math display="inline">b</math> bei Minimum <math display="inline">{\bf w}^{*}</math> und <math display="inline">b^{*}</math> ergibt <math display="block">\left.{\frac{ \partial L({\bf w}, b, {\boldsymbol{\Lambda}})}{\partial {\bf w}}}\right|_{{\bf w}={\bf w}^{*}} = \left({\bf w}^{*} - \sum_{i=1}^N \lambda_i y_i {\bf x}_i \right) =0,</math> und <math display="block">\left.{\frac{ \partial L({\bf w}, b, {\boldsymbol{\Lambda}})}{\partial b}}\right|_{b=b^{*}} = \sum_{i=1}^N \lambda_i y_i =0.</math>

Wenn man sie in die Lagrange-Funktion bei <math display="inline">{\bf w} = {\bf w}^{*}</math> und <math display="inline">b=b^{*}</math> einsetzt, erhält man <math display="block">\begin{aligned}
L({\bf w}^{*}, b^{*}, {\boldsymbol{\Lambda}}) &= \frac{1}{2} {{\bf w}^{*}}^T{\bf w}^{*} - \sum_{i=1}^N \lambda_i y_i {{\bf w}^{*}}^T {\bf x}_i - \sum_{i=1}^N \lambda_i y_i b^{*} + \sum_{i=1}^N \lambda_i\\
&= \frac{1}{2} {{\bf w}^{*}}^T{\bf w}^{*} - {{\bf w}^{*}}^T{\bf w}^{*} + \sum_{i=1}^N \lambda_i \\
&= \sum_{i=1}^N \lambda_i - \frac{1}{2} {{\bf w}^{*}}^T{\bf w}^{*}\\
&= \sum_{i=1}^N \lambda_i - \frac{1}{2} \sum_{i=1}^N \sum_{j=1}^N \lambda_i \lambda_j y_i y_j {\bf x}_i {\bf x}_j.
\end{aligned}</math>

Einführung des Label Vektors <math display="inline">{\bf y}</math> und der symmetrischen Matrix <math display="inline">N \times N</math> <math display="inline">{\bf D}</math> als <math display="block">\begin{aligned}
& {\bf y}^T = (y_1,\ldots, y_N), \\
&{\bf D} = [{\bf D}_{ij}]=[y_i y_j {\bf x}_i {\bf x}_j]
\end{aligned}</math>

ermöglicht die Erstellung eines quadratischen Programms in Vektor-Matrix-Notation für die Lagrange-Multiplikatoren as <math display="block">\begin{aligned}
&\arg \max_{{\boldsymbol{\Lambda}}} L({\boldsymbol{\Lambda}}) = \arg \max_{{\boldsymbol{\Lambda}}} {\boldsymbol{\Lambda}}^T {\bf e} - \frac{1}{2}{\boldsymbol{\Lambda}}^T {\bf D}{\boldsymbol{\Lambda}}, ~ \mathrm{~unter~den~Bedingungen~}~ \\
& {\boldsymbol{\Lambda}}^T {\bf y} = 0, ~ \mathrm{~fuer~}~{\boldsymbol{\Lambda}} \geq {\bf 0},
\end{aligned}</math> wobei <math display="inline">{\bf e}</math> für den <math display="inline">N</math>-dimensionalen Einheitsvektor steht.

<div class="remark">

'''Bemerkung 1'''. ''Die Nebenbedingung <math display="inline">{\boldsymbol{\Lambda}}^T {\bf y} = 0</math> ist dieselbe wie die partielle Ableitung der Lagrange-Funktion nach <math display="inline">b</math> in Vektorform. Die andere partielle Ableitung und die ursprünglichen Nebenbedingungen sind hier nicht notwendig, da die Zielfunktion im obigen quadratischen Programmierproblem nicht von <math display="inline">{\bf w}</math> abhängt.''

</div>
'''''<math display="inline">\mathrm{\ \ \ \ }</math> Die Eigenschaften der optimalen Hyperebene'''''

Nach dem Kuhn-Tucker-Theorem <math display="block">\begin{aligned}
\lambda_{i}^{*} \left(y_i({{\bf w}^{*}}^T{\bf x}_i + b^{*}) \right) = 0, ~~ i= 1, \ldots, N
\end{aligned}</math> gilt für die optimalen Parameter der Lagrange-Funktion. Daraus folgt, dass <math display="inline">\lambda_{i}^{*} \neq 0</math> nur für die Fälle gilt, in denen die Ungleichung-Constraint zu einer Gleichheit wird, d. h. wenn <math display="block">\begin{aligned}
y_i({{\bf w}^{*}}^T{\bf x}_i + b^{*}) - 1 = 0 ~\Leftrightarrow~ y_i({{\bf w}^{*}}^T{\bf x}_i + b^{*}) =1
\end{aligned}</math> gilt. Die Vektoren <math display="inline">{\bf x}_i</math> der Eingabedaten, die die obige Gleichheit erfüllen, werden Support-Vektoren genannt. Dies sind die Vektoren, die zu den an den Klassengrenzen liegenden Hyperebenen passen.

Für die optimale Hyperebene gelten folgende Eigenschaften:

* '''P.1''' Der Parametervektor <math display="inline">{\bf w}^{*}</math> der optimalen Hyperebene kann als lineare Kombination der Support-Vektoren als <math display="block">{\bf w}^{*} = \sum_{i=1}^N \lambda_{i}^{*} y_i {\bf x}_i.</math> ausgedrückt werden.
* '''P.2''' Die Support-Vektoren bestimmen vollständig die optimale Hyperebene, also sowohl <math display="inline">{\bf w}^{*}</math> als auch <math display="inline">b^{*}</math>.
* '''P.3''' Zwischen dem Wert der Lagrange-Funktion im Optimum und dem Margin für die optimale Hyperebene, <math display="inline">\rho^{*}</math> gilt die Relation, <math display="block">L({\bf w}^{*}, b^{*}, {\boldsymbol{\Lambda}}^{*}) = \frac{2}{{\rho^{*}}^2}.</math>

Die Gleichung von '''P.1''' kann durch Umstellen der Gleichung erhalten werden, die als erste Ableitung der Lagrange-Funktion nach <math display="inline">{\bf w}</math> erhalten wurde. Die <math display="inline">{\bf x}_i</math>-s für jedes <math display="inline">\lambda_{i}^{*} \neq 0</math> erfüllen die Gleichheit <math display="inline">y_i({{\bf w}^{*}}^T{\bf x }_i + b^{*}) =1</math> und somit sind sie Support-Vektoren. Daher wird <math display="inline">{\bf w}^{*}</math> in der Expression in '''P.1''' als Linearkombination der Support-Vektoren angegeben. Dies legt nahe, dass nur diese Vektoren des Eingabedaten einen effektiven Beitrag zum Parametervektor <math display="inline">{\bf w}^{*}</math> leisten, was den Namen „Support-Vektor“ erklärt.

Nachdem <math display="inline">{\bf w}^{*}</math> bestimmt wurde, kann <math display="inline">b^{*}</math> durch Einsetzen eines beliebigen Support-Vektoren in die Gleichung <math display="inline">y_i({{\bf w}^{*}}^T {\bf x}_i + b^{*}) =1</math> berechnet werden. Damit ist '''P.2''' gezeigt.

Um '''P.3''' zu zeigen, stellen wir eine Beziehung zwischen <math display="inline">{{\bf w}^{*}}^T {\bf w}^{*}</math> und <math display="inline">\sum_{i=1}^N \lambda_{i}^{*}</math> her als <math display="block">{{\bf w}^{*}}^T {\bf w}^{*}= \sum_{i=1}^N \lambda_{i}^{*} y_i {{\bf w}^{*}}^T {\bf x}_i = \sum_{i=1}^N \lambda_{i}^{*} (1-y_i b^{*}) = \sum_{i=1}^N \lambda_{i}^{*},</math> wobei '''P.1''', die Gleichheit <math display="inline">y_i({{\bf w}^{*}}^T{\bf x}_i + b^{*}) =1</math> für die Support-Vektoren und die Beziehung <math display="inline">\sum_{i=1}^N \lambda_i y_i =0</math> bei <math display="inline">\lambda_i =\lambda_{i}^{*}</math> verwendet wurden. Die Anwendung dieser Beziehung auf die Lagrange-Funktion im Optimum führt zu <math display="block">L({\bf w}^{*}, b^{*}, {\boldsymbol{\Lambda}}^{*}) = \sum_{i=1}^N \lambda_{i}^{*} - \frac{1}{2} {{\bf w}^{*}}^T{\bf w}^{*} = \frac{1}{2} {{\bf w}^{*}}^T{\bf w}^{*}</math> Kombiniert man es mit dem Ausdruck der Margin <math display="inline">\rho({\bf w}, b)=\frac{2}{\lVert {\bf w} \rVert}</math> bei <math display="inline">{\bf w} = {\bf w }^{*}</math> und <math display="inline">b=b^{*}</math> ergibt <math display="block">{\rho^{*}}^2 = \frac{4}{2 L({\bf w}^{*}, b^{*}, {\boldsymbol{\Lambda}}^{*})} = \frac{2}{L({\bf w}^{*}, b^{*}, {\boldsymbol{\Lambda}}^{*})},</math> woraus '''P.3''' direkt folgt.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Optimaler Hyperebenen-Algorithmus'''''

Basierend auf den obigen Unterkapiteln kann ein Algorithmus zur Bestimmung des linearen SVM-Klassifikators mit linear trennbaren Klassen erstellt werden, d. h. um die Parameter <math display="inline">{\bf w}</math> und <math display="inline">b</math> zu berechnen. Dieser optimale Hyperebenen-Algorithmus besteht aus den folgenden Schritten:

# Berechnen das optimale <math display="inline">{{\boldsymbol{\Lambda}}^{*}}^T =(\lambda_1^{*},\ldots,\lambda_N^{*})</math>, durch Löung des quadratischen Programms <math display="block">\begin{aligned}
&\arg \max_{{\boldsymbol{\Lambda}}} L({\boldsymbol{\Lambda}}) = \arg \max_{{\boldsymbol{\Lambda}}} {\boldsymbol{\Lambda}}^T {\bf e} - \frac{1}{2}{\boldsymbol{\Lambda}}^T {\bf D}{\boldsymbol{\Lambda}}, ~ \mathrm{~unter~den~Bedingungen~}~ \\
& {\boldsymbol{\Lambda}}^T {\bf y} = 0, ~ \mathrm{~fuer~}~{\boldsymbol{\Lambda}} \geq {\bf 0},
\end{aligned}</math>
# Berechnen die optimalen Parametergewichte <math display="inline">{\bf w}^{*}</math> basierend auf der Eigenschaft '''P.1''', d. h. aus <math display="inline">\lambda_{i}</math>-s und aus den Support-Vektoren unter Verwendung der Gleichung <math display="block">{\bf w}^{*} = \sum_{i=1}^N \lambda_{i}^{*} y_i {\bf x}_i.</math>
# Berechnen den Parameter <math display="inline">b^{*}</math>, indem einen Support-Vektor in die Gleichung <math display="inline">y_i({{\bf w}^{*}}^T{\bf x}_i + b^{*}) =1</math> eingesetzt wird.


=== Lineare SVM mit linear nicht trennbaren Klassen ===

Wenn die Klassen linear nicht trennbar sind, gibt es keine Hyperebene, die alle Trainingsbeispiele korrekt trennen kann. In diesem Fall kann man nach der Hyperebene suchen, die die meisten Trainingsbeispiele trennen kann, d. h. was den geringsten Fehler bei der Trennung macht. Daher muss der Fehler bei der Trennung in die Formulierung der Optimierungsaufgabe zum Finden der optimalen Hyperebene einbezogen werden.

<div id="fig:SVM_4" class="figure">

[[Datei:SVM_cmu_edu_1.jpg|460px|thumb|center|Abbildung 28: Hyperebene für linear nicht trennbare Klassen mit fehlerhaft getrennten Trainingsbeispielen (Quelle: [https://www.cs.cmu.edu/~aarti/Class/10701_Spring21/Lecs/svm_dual_kernel_inked.pdf cmu_edu]).]] 

</div>

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Optimierungsaufgabe zum Finden der optimalen Hyperebene'''''

Sei <math display="inline">\xi_i</math> der Fehler des fälschlicherweise getrennten Trainingsbeispiels <math display="inline">{\bf x}_i</math>, der im der ausgewählten Hyperebene zugeordneten Margin liegt, siehe Abbildung [[#fig:SVM_4|28]]. Die Trainingsbeispiele mit <math display="inline">\xi_i=0</math> (grüne Kreise) sind Support-Vektoren. Die Trainingsbeispiele mit <math display="inline">0 < \xi_i < 1</math> (lila Kreise) sind richtig klassifiziert, liegen aber innerhalb des Margins. Die Trainingsbeispiele mit <math display="inline">1 < \xi_i</math> (lila Kreise) sind falsch klassifiziert. Die zuvor für die linear separierbaren Klassen festgelegte Nebenbedingungen müssen geändert werden, da die fehlerhaft separierten Trainingsbeispiele innerhalb des Margins liegen. Die richtige Nebenbedingung, die den Fehler des fälschlicherweise getrennten Trainingsbeispiele berücksichtigt, kann wie folgt formuliert werden:

<math display="block">y_i({\bf w}^T {\bf x}_i + b) \geq 1 - \xi_i, ~~ \mathrm{~wobeie~}~~\xi_i \geq 0, ~~i=1,\ldots,N.</math>

Jetzt wollen wir nicht nur <math display="inline">\lVert {\bf w} \rVert^2</math> sondern auch den Gesamtfehler bei der Trennung minimieren, um einen großen Margin zu haben. Hier den Gesamtfehler kann als <math display="block">\sum_{i=1}^{N} \xi_i</math> ausgedrückt werden.

Je kleiner der Wert <math display="inline">\lVert {\bf w} \rVert^2</math>, desto größer der Margin, was zu einem größeren Gesamtfehler bei der Trennung führt. Somit stehen der Wert <math display="inline">\lVert {\bf w} \rVert^2</math> und der Gesamtfehler bei der Trennung im Kompromiss zueinander. Daher ist die Optimierungsaufgabe mit Nebenbedingungen zum Finden der optimalen Hyperebene für linear nicht trennbare Klassen wird durch <math display="block">\begin{aligned}
&({\bf w}, b) = \arg \min_{{\bf w}, b} \frac{1}{2}\lVert {\bf w} \rVert^2 + G \sum_{i=1}^{N} \xi_i, ~ \mathrm{~unter~den~Bedingungen~}~ \\
& y_i({\bf w}^T {\bf x}_i + b) \geq 1- \xi_i, ~~ \mathrm{~und~}~~\xi_i \geq 0, ~~i=1,\ldots,N
\end{aligned}</math> gegeben, wobei <math display="inline">G</math> eine Konstante ist, die die Gewichtung der beiden zu minimierenden Ziele festlegt. Die optimale Hyperebene wird Soft-Margin-Hyperebene genannt. Der Name kommt von der Art dieses Margin, der das Überhängen mehrerer Trainingsbeispiele ermöglicht. Es kann gezeigt werden, dass alle Eigenschaften '''P.1''' - '''P.3''' auch für diesen nicht trennbaren Fall gelten.

<div class="remark">

'''Bemerkung 2'''. ''Wenn diese Optimierung mit einem hohen Wert von <math display="inline">G</math> angewendet wird, dann verhält sie sich ähnlich wie die Optimierung für trennbare Klassen.''

</div>

=== SVM mit nichtlinearem Kernel ===

Im Fall linear nicht trennbarer Klassen kann eine bessere Trennbarkeit durch die Verwendung einer nichtlinearen Entscheidungsfläche anstelle einer Hyperebene erreicht werden. Dies wird in Abbildung [[#fig:SVM_5|29]] veranschaulicht.

<div id="fig:SVM_5" class="figure">

[[Datei:SVM_WIPE_2a.jpg|460px|thumb|center|Abbildung 29: Nichtlineare Entscheidungsfläche für nicht trennbare Klassen (Quelle: [https://en.wikipedia.org/wiki/Support_vector_machine Wikipedia_SVM]).]] 

</div>

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Die Idee der nichtlinearen SVM'''''

Aus diesem Grund wird die Theorie der Support Vector Machine auf nichtlineare Entscheidungsflächen erweitert. Die Idee dieser Erweiterung besteht darin, die Eingabevektoren <math display="inline">{\bf x}_i</math> in <math display="inline">M</math>-dimensionale Vektoren umzuwandeln, indem eine <math display="inline">M</math>-dimensionale Vektorfunktion <math display="inline">\phi()</math> auf sie angewendet und dann eine optimale Hyperebene im <math display="inline">M</math>-dimensionalen Raum der transformierten Vektoren konstruiert wird. Durch richtig ausgewählte Vektorfunktion <math display="inline">\phi()</math> werden die transformierten Klassen im <math display="inline">M</math>-dimensionalen Raum wieder durch eine optimale Hyperebene linear trennbar ! Dies ist in Abbildung [[#fig:SVM_6|30]] illustriert.

<div id="fig:SVM_6" class="figure">

[[Datei:SVM_WIPE_2.jpg|460px|thumb|center|Abbildung 30: Nichtlineare Entscheidungsfläche für nicht trennbare Klassen (Quelle: [https://en.wikipedia.org/wiki/Support_vector_machine Wikipedia_SVM]).]] 

</div>

Dann ist die potentielle Entscheidungsgrenze eine <math display="inline">M</math>-dimensionale Hyperebene für die transformierten Vektoren <math display="inline">{\boldsymbol{\phi}}({\bf x}_i) = (\phi_1({\bf x}_i), \ldots, \phi_M( {\bf x}_i)</math>, für <math display="inline">i=1,\ldots,N</math> mit den Parametern <math display="inline">{\bf w}</math> und <math display="inline">b</math>, welche die Form <math display="block">f({\bf x}) = {\bf w}^T {\boldsymbol{\phi}}({\bf x}) + b</math> hat.

Unter Anwendung der Eigenschaft '''P.1''' der Soft-Margin-Hyperebene im <math display="inline">M</math>-dimensionalen Raum der transformierten Vektoren kann der optimale Parametervektor <math display="inline">{\bf w}^{*}</math> als Linearkombination von der Support-Vektoren im transformierten Raum als <math display="block">{\bf w}^{*} = \sum_{i=1}^{N} \lambda_i^{*} y_i {\boldsymbol{\phi}}({\bf x}_i)</math> bestimmt werden. Wenn man es in die Expression der Entscheidungsgrenze einsetzt, kann man die Entscheidungsfläche <math display="inline">f^{*}({\bf x})</math> als <math display="block">f^{*}({\bf x}) = \sum_{i=1}^{N} \lambda_i^{*} y_i {\boldsymbol{\phi}}({\bf x})^T {\boldsymbol{\phi}}({\bf x}_i) + b^{*}.</math> ausdrücken.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Der Kernel-Trick'''''

Das einzige Rechenproblem besteht darin, potenzielle hochdimensionale Räume zu behandeln, die in <math display="inline">{\boldsymbol{\phi}}({\bf x})</math> für große Werte von <math display="inline">M</math> entstehen. Tatsächlich ist es jedoch nicht erforderlich. Die Entscheidungsfunktion (decision function) <math display="inline">f^{*}({\bf x})</math> hängt nur vom Skalarprodukt <math display="inline">{\boldsymbol{\phi}}({\bf x})^T {\boldsymbol{\phi}}({\bf x}_i)</math> und nicht von den einzelnen Vektoren <math display="inline">{\boldsymbol{\phi}}({\bf x})</math> und <math display="inline">{\boldsymbol{\phi}}({\bf x}_i)</math> ab. Unter bestimmten Bedingungen gibt es Funktionen K('''u''', '''v'''), die wie folgt faktorisiert werden können. <math display="block">K({\bf u}, {\bf v}) = {\boldsymbol{\phi}}({\bf u}) {\boldsymbol{\phi}}({\bf v}).</math>

Mit einer solchen Funktion <math display="inline">K({\bf u}, {\bf v})</math> kann die Entscheidungsgrenze <math display="inline">f^{*}({\bf x})</math> in der Form <math display="block">f^{*}({\bf x}) = \sum_{i=1}^{N} \lambda_i^{*} y_i K({\bf x}, {\bf x}_i) + b^{*}</math> geschrieben werden. Die Funktion <math display="inline">K({\bf u}, {\bf v})</math> eine Skalarfunktion ist. Dies bedeutet, dass es ausreicht, statt potenziell hochdimensionalen Vektorfunktionen <math display="inline">{\boldsymbol{\phi}}</math> zunächst einen von interner Form von <math display="inline">K(,)</math> abhängigen Operator, wie z.B. Skalarprodukt oder eine beliebige Distanz, auf die Vektoren <math display="inline">{\bf x}</math>, <math display="inline">{\bf x}_i</math> anzuwenden, und das Ergebnis dann in die Skalarfunktion <math display="inline">K()</math> einzusetzen, die dann rechnerisch leicht berechenbar ist.

Die Funktion <math display="inline">K({\bf u}, {\bf v})</math> wird Kernel genannt und die Idee, sie zu verwenden, anstatt die Vektorenfunktion <math display="inline">{\boldsymbol{\phi}}()</math> zu behandeln, was die Berechnung leicht berechenbar macht, nennt man Kernel-Trick. Maschinen, die den Kernel-Trick anwenden, werden Kernel-Maschinen benannt.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Eigenschaften von SVM mit nichtlinearem Kernel'''''

Die Hauptmerkmale von SVM mit nichtlinearem Kernel kann wie folgt zusammengefasst werden.

# Seine Entscheidungsfunktion <math display="inline">f^{*}({\bf x})</math> kann mit der Hilfe Kernel <math display="inline">K({\bf x}, {\bf x}_i)</math> ausgedrückt werden.
# Seine Entscheidungsfunktion ist nichtlinear im Raum des Eingabevektors.
# Der nichtlinear transformierte Vektorraum kann hochdimensional sein.
# Die nichtlineare Entscheidungsfläche ist eine Soft-Margin-Hyperebene im transformierten Vektorraum.
# Die Entscheidungsfläche wird mit dem Soft-Margin-Hyperplane-Algorithmus berechnet, mit der einzigen Unterschied zur Einstellung der Matrix <math display="inline">{\bf D}</math> als <math display="block">{\bf D} = [{\bf D}_{ij}]=[y_i y_j K({\bf x}_i, {\bf x}_j)].</math>

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Ausgewählte nichtlineare Kernel'''''

Nachfolgend sind einige häufig verwendete nichtlineare Kernel aufgeführt.

* Polynomkernel – für Klassifikator vom Grad <math display="inline">d</math> <math display="block">K({\bf u}, {\bf v}) = ({\bf u} {\bf v} + a)^d</math> Für <math display="inline">a=0</math> und <math display="inline">d=1</math> wird es zum linearen Kernel.
* Potentialfunktion <math display="block">K({\bf u}, {\bf v}) = exp\left(- \frac{\lVert {\bf u} - {\bf v} \rVert)}{\sigma}\right)</math>
* Gaußsche Radialfunktion als Kernel (Gaussian radial function) <math display="block">K({\bf u}, {\bf v}) = exp\left(- \frac{\lVert {\bf u} - {\bf v} \rVert^2)}{2 \sigma^2}\right)</math>
* Sigmoid- oder hyperbolische Tangensfunktion <math display="block">K({\bf u}, {\bf v}) = \tanh \left(\alpha {\bf u} {\bf v} + \beta \right), \mathrm{~fuer~einige~} \alpha > 0 \mathrm{~und~} \beta < 0</math>


=== Erweiterungen ===

SVM verfügt über mehrere Erweiterungen. Nachfolgend befindet sich eine kurze Zusammenfassung der wichtigsten von denen.

* Multiklassen-SVM. Multiclass SVM ist ein Klassifikator, der für mehr als zwei Klassen entwickelt wurde. Der vorherrschende Realisierungsansatz führt auf Klassifikatoren mit zwei Klassen zurück. Eine dieser Methoden ist die Eins-gegen-Alle-Methode (one-versus-all), bei der für jede Klasse ein Klassifikator angewendet wird, um sie vom Rest zu trennen, und der Klassifikator mit der höchsten Ausgabe gewinnt.
* Transduktive SVM. Transduktive SVM realisiert halbüberwachtes Lernen. Neben dem beschrifteten Trainingdaten wird ein unbeschriftet Daten von Vektoren <math display="inline">{\bf x}^{'}_j</math>, <math display="inline">j=1,\ldots, U</math> bereitgestellt. Die Optimierungsaufgabe wird modifiziert, indem neben den Parametern <math display="inline">{\bf w}</math> und <math display="inline">b</math> auch nach den vorherzusagenden Labels <math display="inline">y^{'}_j</math> gesucht wird und die Nebenbedingungen durch <math display="inline">y^{'}_i ( {\bf w}^T {\bf x}_i + b) \geq 1</math> und <math display="inline">y^{'}_i \in {-1,1}</math> ergänzt werden.
* Support-Vektor-Clustering (SVC). SVC ist eine Maschine, die unüberwachtes Lernen realisiert.
* Strukturierte SVM (structured SVM). Strukturierte SVM ist eine Verallgemeinerung von SVM, die strukturierte und unendlich viele Labels ermöglicht.
* Support-Vector-Regression (SVR). SVR basiert auf der an die Regression angepassten SVM-Theorie. Jetzt ist <math display="inline">{\bf w}^T {\bf x}_i + b</math> der vorhergesagte Wert und <math display="inline">y_i</math> die richtige Ausgabe, wobei beide stetige Werte annehmen. Dann wird die Regression durch die Optimierungsaufgabe mit der Nebenbedingung <math display="inline">|y_i - ({\bf w}^T {\bf x}_i + b)|\leq \epsilon</math> bestimmt, wobei <math display="inline">\epsilon</math> ein freier Schwellenwert für Fehler (error threshold) ist.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Implementierung'''''

Normalerweise ist vor der Berechnung von SVM eine Vorverarbeitung der Trainingsdaten erforderlich. Zu den notwendigen Vorverarbeitungsschritten gehören:

* Skalierung mit Methoden wie Min-Max, Dezimalskalierung (decimal scaling) oder Z-Score.
* Mittelwertnormalisierung (mean normalization), d. h. Subtrahieren des Mittelwerts von den Vektoren.
* Varianznormalisierung (variance normalization), d. h. Division jeder Vektorkomponente durch ihre Varianz.

Kernel SVM ist in vielen ML Softwarepaketen implementiert, darunter unter anderem

* P-Pack SVM mit Subgradienten-Verfahren,
* MATLAB, SAS,
* LIBSVM, SVMlight,kernlab, JKernelMachines und
* scikit-learn Python-Bibliothek.


== Entscheidungsbäume und Random Forests ==

Klassifikations- und Regressionsbäume (Classification and Regression Trees - CART) sind Entscheidungsbäume, die für Klassifikations- und Regressionsaufgaben verwendet werden können. In diesem Unterabschnitt diskutieren wir den Ansatz von Entscheidungsbäume für Klassifikationsaufgaben.

Klassifikationsbäume realisieren eine hierarchische Partitionierung des Raumes der Eingabevektoren. Die Eingabevektoren werden auch als Featurevektoren genannt, da jede einzelne Komponente der Eingabevektoren ein Merkmal (also Feature) darstellt. Die Partitionierung führt zu einzelnen disjunkten Bereichen des Raumes der Eingabevektoren, von denen jeder einer Klasse zugeordnet ist. Die Grundidee des Klassifikationsbaums ist also die Zuordnung disjunkter Bereiche des Raumes der Eingabevektoren zu Klassen, was sich wesentlich von den Ideen anderer Klassifikationsmethoden unterscheidet, wie z. B. neuronalen Netzen, die Diskriminanzfunktionen realisieren, oder Support Vector Machines, die Entscheidungsgrenzen als Hyperebene realisieren.


=== Ein medizinisches Beispiel ===

In einem medizinischen Beispiel werden die Patienten in Hochrisiko- und Niedrigrisiko-Patienten eingeteilt. Die Einteilung erfolgt durch Fragen an die Patienten. Die Fragen können in einem binären Baum organisiert werden, siehe Abbildung [[#fig:CART_Med_Exa|31]].

<div id="fig:CART_Med_Exa" class="figure">

[[Datei:CART_1_MedExa.jpg|460px|thumb|center|Abbildung 31: Ein medizinisches Beispiel für einen Klassifikationsbaum (Quelle: [CARTPennStateCourse(2024)]).]] 

</div>

Jede Frage bezieht sich auf ein Merkmal (Feature), das eine Variable im Raum der Eingabevektoren darstellt. Solche Variablen sind systolischer Blutdruck, Alter und das Vorhandensein einer Sinustachykardie. Somit verwendet die Aufgabe einen dreidimensionalen Raum der Eingabevektoren, wobei zwei Dimensionen sind kontinuierlich, während die letzte diskret ist (kann nur den Wert logisch wahr oder falsch aufnehmen). Auf diese Weise entspricht jedes Blatt des Binärbaums einem disjunkten Bereich des Raums der Eingabevektoren.


=== Erstellen eines Entscheidungsbaums ===

Der Entscheidungsbaum wird iterativ aufgebaut, wobei in jeder Iteration eine der resultierenden Regionen der vorherigen Iteration in zwei weitere disjunkte Regionen aufgeteilt wird. Jede Region wird normalerweise entlang einer Komponente des Eingabevektors aufgeteilt. Dies entspricht einer Frage wie „Ist <math display="inline">x_j \leq k</math>, wobei die Aufteilung entlang der <math display="inline">j</math>-ten Komponente der Eingabevektoren durchgeführt wird und <math display="inline">k</math> eine mögliche Position für die Aufteilung ist. Dies wird in Abbildung [[#fig:CART_Split_Steps|32]] veranschaulicht.

<div id="fig:CART_Split_Steps" class="figure">

{| class="wikitable"
|-
| style="text-align: left;"| [[Datei:CART_2p1.jpg|300px|thumb|center|]]
| style="text-align: left;"| [[Datei:CART_2p2.jpg|300px|thumb|center|]]
| style="text-align: left;"| [[Datei:CART_2p3.jpg|300px|thumb|center|]]
|}
Abbildung 32: Veranschaulichung der iterativen Aufteilung des Raums der Eingabevektoren in jedem Schritt entlang einer Komponente des Eingabevektors (Quelle: [CARTPennStateCourse(2024)]).

</div>

Dabei ist <math display="inline">X</math> der gesamte Raum der Eingabevektoren und <math display="inline">X_i</math>-s, <math display="inline">i= 1,\ldots</math> stehen für die einzelnen Regionen des Raums der Eingabevektoren als Ergebnis der aktuellen Aufteilung. Aufgrund der binären Baumdarstellung wächst der Baum in jeder Iteration und jede Region kann auch als Knoten im binären Baum dargestellt werden.

Um den Entscheidungsbaum mittels der oben beschriebenen iterativen Aufteilung zu konstruieren, müssen die Teilaufgaben im Voraus festgelegt werden.

* Auswahl der nächsten Aufteilung (split), d. h. Entscheidung, welcher Knoten (d. h. Region) und wie aufgeteilt werden soll.
* Bereitstellung eines Abbruchkriteriums (stopping criterion) für das Wachstum des Baums.
* Zuweisen einer Klasse zu jedem Blatt des endgültigen Baums.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Auswahl der nächsten Aufteilung'''''

Es besteht der Bedarf an einem Maß, mit deren Hilfe aus allen Kandidaten-Aufteilungen die nächstbeste Aufteilung ausgewählt werden kann. Jeder 
Kandidaten-Aufteilung kann durch den aufzuteilenden Knoten <math display="inline">t</math> und eine Aufteilung <math display="inline">s</math> angegeben werden, der die für die Aufteilung zu verwendende Komponente des Eingabevektors und seine Position angibt.

Ein häufig verwendetes Maß zur Auswahl der nächstbesten Aufteilung ist das Maß „Goodness of split“ („Güte der Aufteilung“). Die "Goodness of split" einer Kandidaten-Aufteilung kann jedoch berechnet werden, indem die Impurity-Funktion (Unreinheitsfunktion) auf einige Knoten angewendet wird. Daher führen wir zunächst die Impurity-Funktion ein.

''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Die Impurity-Funktion''

Intuitiv ist eine Region „rein“, wenn die meisten Punkte (d. h. Beispiele der Trainingsdaten) zur selben Klasse gehören. Dazu muss gemessen werden, wie unrein (impure) eine Region ist. Ein Beispiel zum Erstellen reiner Regionen in zwei Aufteilungsschritten ist in Abbildung [[#fig:CART_Clear_Regions|33]] dargestellt.

<div id="fig:CART_Clear_Regions" class="figure">

{| class="wikitable"
|-
| style="text-align: left;"| [[Datei:CART_3p1.jpg|800px|thumb|center|]]
| style="text-align: left;"| [[Datei:CART_3p2.jpg|800px|thumb|center|]]
|}
Abbildung 33: Ein Beispiel zum Erstellen reiner Regionen in zwei Aufteilungsschritten (Quelle: [CARTPennStateCourse(2024)]).

</div>

Nach der ersten Aufteilung gehören nur zwei Punkte auf der linken Seite zur durch Kreise gekennzeichneten Klasse. Durch Anwenden der zweiten Teilung ist es möglich, einen Baum mit 100 % reinen Knoten zu erhalten. Man kann beobachten, dass nach jedem Aufteilungsschritt die Reinheit zunimmt oder gleichwertig die Impurity abnimmt.

Seien <math display="inline">p_1, \ldots, p_C</math> die Wahrscheinlichkeiten, dass ein markierter Datenpunkt in der Region zur Klasse <math display="inline">1,\ldots, C</math> gehört. Dann ist die Impurity-Funktion <math display="inline">\phi()</math> auf <math display="inline">p_1, \ldots, p_C</math>, <math display="inline">p_c \geq 0</math> für <math display="inline">c=1,\ldots, C</math> und <math display="inline">\sum_{c=1}^C p_c = 1</math> durch ihre folgenden Eigenschaften definiert:

# Die Funktion <math display="inline">\phi()</math> hat ein Maximum nur bei gleichmäßig verteilten <math display="inline">p_c</math>-s, d. h. wenn alle <math display="inline">p_c</math>-s gleich sind.
# Die Funktion <math display="inline">\phi()</math> hat ein Minimum an Punkten, wenn einer der <math display="inline">p_c</math>-Werte <math display="inline">1</math> und alle anderen <math display="inline">0</math> sind.
# Die Funktion <math display="inline">\phi()</math> ist symmetrisch in <math display="inline">p_1, \ldots, p_C</math> 
<math display="inline">\Rightarrow</math> <math display="inline">\phi()</math> hat für jede Permutation von <math display="inline">p_1, \ldots, p_C</math> den gleichen Wert.

Sei <math display="inline">p(t)</math> die Wahrscheinlichkeit, dass ein Punkt (= Featurevektor eines Beispiels einer Trainingsdata) im Knoten <math display="inline">t</math> liegt. Ähnlich sei <math display="inline">p(c,t)</math> die Wahrscheinlichkeit, dass ein Punkt im Knoten <math display="inline">t</math> liegt und zur Klasse <math display="inline">c</math> gehört. Darüber hinaus sei <math display="inline">p(c|t)</math>, <math display="inline">c=1,\ldots,C</math> die bedingte Wahrscheinlichkeit, dass ein Punkt zur Klasse <math display="inline">c</math> gehört, vorausgesetzt, dass er im Knoten <math display="inline">t</math> liegt. Diese bedingten Wahrscheinlichkeiten können basierend auf ihren Definitionen als <math display="inline">p(c|t) = \frac{p(c,t)}{p(t)}</math> berechnet werden. Dann ist das Impurity-Measure (Unreinheitsmaß) des Knotens <math display="inline">t</math>, <math display="inline">i(t)</math> als <math display="block">i(t) = \phi\left(p(1|t), p(2|t),\ldots, p(C|t)\right)</math> gegeben.

Die am häufigsten verwendeten Impurity-Funktionen sind

# Entropie (entropy): <math display="inline">\sum_{c=1}^C p_c log \frac{1}{p_c}</math> (For <math display="inline">p_c = 0</math> apply <math display="inline">\lim_{p_c \rightarrow 0 } p_c log \frac{1}{p_c} = 0</math>.)
# Fehlklassifizierungsrate (missclassification rate): <math display="inline">1-\max_{c}p_c</math>.
# Gini-Index (Gini index): <math display="inline">\sum_{c=1}^C p_c(1-p_c) = 1 - \sum_{c=1}^C p_c^2</math>.

Es ist wichtig zu verstehen, dass es egal ist, welche Impurity-Funktion angewendet wird, da ihre Fähigkeit zur Messung der Impurity durch ihre Eigenschaften gewährleistet wird, die für alle Impurity-Funktionen gelten.

''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Auswahl basierend auf dem Maß „Goodness of split“''

Der linke und rechte Kindknoten des Knotens <math display="inline">t</math> werden jeweils als <math display="inline">t_L</math> und <math display="inline">t_R</math> bezeichnet. <math display="inline">p(t_L)</math> und <math display="inline">p(t_R)</math> bezeichnen die Wahrscheinlichkeit, dass sich ein Punkt im Knoten <math display="inline">t_L</math> bzw. <math display="inline">t_R</math> befindet. Dann sind die bedingten Wahrscheinlichkeiten, dass sich ein Punkt im Knoten <math display="inline">t_L</math> und <math display="inline">t_R</math> befindet, wenn der Punkt im Knoten <math display="inline">t</math> ist, durch

<math display="block">\begin{aligned}
&p_L = \frac{p(t_L)}{p(t)} \\
&p_R = \frac{p(t_R)}{p(t)}
\end{aligned}</math> gegeben.

Basierend auf der Definition von <math display="inline">i(t)</math> kann die „Goodness of split“ einer 
Kandidaten-Aufteilung <math display="inline">s,t</math> als die Differenz der Impurity des Knotens <math display="inline">t</math> und der gewichteten Summe der Impurity der linken und rechten untergeordneten Knoten angegeben werden. Mit anderen Worten

<math display="block">\phi(s,t) = \Delta i(s,t)= i(t) - p_L i(t_L) - p_R i(t_R).</math>

Somit drückt die oben definierte „Goodness of split“ den Gewinn aus, wenn der Kandidaten-Aufteilung <math display="inline">(s,t)</math> angewendet wird, d. h. wenn die durch <math display="inline">s</math> angegebene Aufteilung auf Knoten <math display="inline">t</math> angewendet wird. Hier sind <math display="inline">p_L</math> und <math display="inline">p_R</math> Gewichte oder Anteile von Punkten, die zu linken und rechten Knoten gehen.

Die gewichtete Impurity (weighted impurity) des Knotens <math display="inline">t</math> wird definiert als <math display="block">I(t) = p(t)i(i).</math> Dies kann als die Impurity des Knotens <math display="inline">t</math> interpretiert werden, gewichtet mit dem Anteil seiner Punkte im Baum.

Dann wird die Differenz des gewichteten Impurity-Mass des übergeordneten Knotens <math display="inline">t</math> und der linken und rechten untergeordneten Knoten definiert als <math display="block">\begin{aligned}
\Phi(s,t) &= \Delta I(s,t)= I(t) - I(t_L) - I(t_R)= p(t)i(t) - p(t_L)i(t_L) - p(t_R)i(t_R) \\
&= p(t)i(t) - p(t)p_L i(t_L) - p(t)p_R i(t_R) = p(t)\Delta i(s,t).
\end{aligned}</math>

''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Auswahl basierend auf der Twoing Rule''

Eine andere Möglichkeit, die nächste Aufteilung auszuwählen, ist die Anwendung der Twoing Rule. Diese Regel wählt die nächste Aufteilung aus, die den Gesamtunterschied der Posterior-Wahrscheinlichkeiten der Klassen maximiert und die Anteile der Punkte ausgleicht, die auf die untergeordneten Knoten fallen. Mit anderen Worten wählt die Twoing Rule am Knoten <math display="inline">t</math> die Aufteilung aus, die das Optimierungskriterium

<math display="block">\max_{s} \frac{p_L p_R}{4}\left(\sum_{c} |p(c|t_L) - p(c|t_R)| \right)^2</math> erfüllt.

Der Term in der Klammer stellt die Gesamtdifferenz der 
Posterior-Wahrscheinlichkeiten der Klassen dar, während der Multiplikationsfaktor <math display="inline">\frac{p_L p_R}{4}</math> im Maximumkriterium das Ausgleichsziel umsetzt.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Das Problem des guten Abbruchkriterium'''''

Wenn man die "Goodness of split" zur Auswahl der nächsten Aufteilung anwendet, ist zu erwarten, dass die gewichtete Impurity mit jedem Schritt abnimmt. Der Baum, der durch iterative Auswahl der nächstbesten Aufteilung wächst, ist jedoch ein Greedy Algorithmus. Daher kann auf eine schlechte Aufteilung mit niedrigem <math display="inline">\Delta I(s,t)</math> eine gute Aufteilung mit höherem <math display="inline">\Delta I(s,t)</math> folgen. Daher wäre ein Abbruchkriterium wie das Abbrechen des Wachstums des Entscheidungsbaums, wenn <math display="inline">\Delta I(s,t)</math> unter einen bestimmten Schwellenwert fällt, kein zufriedenstellendes Abbruchkriterium. Ebenso würde ein „Vorausblick“ auf weitere Schritte in der Entwicklung von <math display="inline">\Delta I(s,t)</math> dieses Problem nicht lösen, da die weitere Entwicklung von <math display="inline">\Delta I(s,t)</math> nach diesen Schritten unbekannt ist, d. h. eine gute Aufteilung mit höherem <math display="inline">\Delta I(s,t)</math> könnte auch nach diesen Schritten folgen.

Daher kann auf diese Weise kein gutes Abbruchkriterium festgelegt werden. Deshalb lässt sich die richtige Strategie wie folgt feststellen.

* Lassen den Baum zunächst wachsen, bis er ausreichend groß ist, und
* Prune (beschneiden) ihn dann gemäß einem zufriedenstellenden Kriterium, siehe Unterabschnitt [[#subsec:prune|4.2.3]].

Das Erreichen einer ausreichend großen Größe kann beispielsweise anhand eines der folgenden Kriterien entschieden werden.

* Lassen den Baum wachsen, bis alle Knoten rein sind (= nur noch eine Klasse enthalten).
* Lassen den Baum wachsen, bis die Anzahl der Datenpunkte unter eine vordefinierte Grenze fällt, z. B. 6.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Zuweisen eine Klasse jedem Blatt''''' 

Nachdem der Entscheidungsbaum fertig ist, wird jedem Blatt eine Klasse zugewiesen. Die angewandte Regel ist unkompliziert: Jedem Blatt wird die Klasse mit der höchsten Wahrscheinlichkeit zugewiesen. Mit anderen Worten: Die dem Blattknoten <math display="inline">t</math> zugewiesene Klasse <math display="inline">c^*(t)</math> kann als

<math display="block">c^*(t) = \arg\max_{c} p(c|t)</math> gegeben werden.


=== Pruning ===

Die Beschreibung des Pruning (Beschneidung) bedarf einiger Vorüberlegungen (preliminary considerations).

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Vorüberlegungen'''''

''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Optimale Teilbäume''

Das Finden eines optimalen Teilbaums mittels erschöpfender Suche ist keine praktikable Strategie, da die Anzahl der Teilbäume auch bei einem mittelgroßen Baum beträchtlich groß sein kann. Stattdessen wird eine effizientere Methode benötigt, die die folgenden Voraussetzungen erfüllt.

* Der Teilbaum nach dem Pruning sollte in einem vordefinierten Sinne optimal sein.
* Die Methode zur Bestimmung dieses optimalen Teilbaums sollte rechnerisch handhabbar sein.

''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Fehlklassifizierungsrate''

Die Fehlklassifizierungsrate ist die Wahrscheinlichkeit der Fehlklassifizierung (misclassification) in einem bestimmten Blattknoten, welche durch die Resubstitutionsschätzung (resubstitution estimate) <math display="inline">r(t)</math> charakterisiert wird. Aufgrund der Klassenzuweisungsregel (class assign rule), dass jedem Blatt die Klasse mit der höchsten Wahrscheinlichkeit zugewiesen wird, ist <math display="inline">r(t)</math> gegeben als

<math display="block">r(t) = 1- p(c^*(t)|t) = 1 - \max_{c} p(c|t).</math>

Wir definieren <math display="inline">R(t)= r(t)p(t)</math>. Seien <math display="inline">T</math> und <math display="inline">\tilde{T}</math> die Bezeichnungen des gesamten Baums bzw. der Menge der Blattknote. Der Klassifizierungsfehler für den gesamten Baum, <math display="inline">R(T)</math>, ist definiert als die Summe der gewichteten Resubstitutionsschätzung über die Menge der Blattknoten, <math display="inline">\tilde{T}</math>, mit anderen Worten <math display="block">R(T) = \sum_{t \in \tilde{T}} R(t) = \sum_{t \in \tilde{T}} r(t)p(t).</math>

Eine wesentliche Aussage ist, dass die Aufteilung eines Knotens in zwei Kindknoten immer den Klassifizierungsfehler für den gesamten Baum verringert. Dies folgt aus <math display="block">R(t) \geq R(t_L) + R(t_LR),</math>

welches eine Folge der Klassenzuweisungsregel ist und kann wie folgt nachgewiesen werden.

<math display="block">\begin{aligned}
p(c^*(t)|t) &= p(c^*(t), t_L|t) + p(c^*(t), t_R|t) = p(c^*(t)| t_L)p(t_L|t) + p(c^*(t)|t_R)p(t_R|t) \\
&= p(c^*(t)| t_L)p(t_L|t) + p(c^*(t)|t_R)p(t_R|t) = p_L p(c^*(t)| t_L) + p_R p(c^*(t)|t_R) \\
&\leq p_L \max_{c} p(c|t_L) + p_R \max_{c} p(c|t_R).
\end{aligned}</math>

Daher gilt <math display="block">\begin{aligned}
r(t) &= 1- p(c^*(t)|t) \geq 1 - \left(p_L \max_{c} p(c|t_L) + p_R \max_{c} p(c|t_R) \right) \\
&= p_L \left(1-\max_{c} p(c|t_L)\right) + p_R \left(1-\max_{c} p(c|t_R)\right)= p_L r(t_L) + p_R r(t_R),
\end{aligned}</math>

aus denen <math display="block">\begin{aligned}
R(t) &= p(t)r(t) \geq p(t) p_L r(t_L) + p(t) p_R r(t_R) \\
&= p(t_L)r(t_L) + p(t_R)r(t_R) = R(t_L)+R(t_R)
\end{aligned}</math> folgt.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Minimal Cost-Complexity Pruning'''''

''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Begriffe und Notationen''

Zur Beschreibung des Prunings werden verschiedene Begriffe und Notationen eingeführt.

* Descendant (Nachkomme): Ein Knoten <math display="inline">t_2</math> ist ein Descendant von Knoten <math display="inline">t_1</math>, wenn es einen Pfad von <math display="inline">t_1</math> nach unten im Baum zu Knoten <math display="inline">t_2</math> gibt.
* Ancestor (Vorfahr): <math display="inline">t_1</math> ist Ancestor von <math display="inline">t_2</math>, wenn <math display="inline">t_2</math> ein Descendant von <math display="inline">t_1</math> ist.
* Branch (Zweig) <math display="inline">T_t</math> des Baums <math display="inline">T</math> mit Wurzelknoten <math display="inline">t \in T</math>: besteht aus Knoten <math display="inline">t</math> und allen seinen Descendants.
* Pruning a branch (Das Beschneiden eines Zweigs) <math display="inline">T_t</math> aus einem Baum <math display="inline">T</math> bedeutet das Löschen aller Knoten des Zweigs <math display="inline">T_t</math>, außer dem Wurzelknoten.

''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Kosten-Komplexität-Kriterium (cost-complexity criterion) zum Finden des optimalen Teilbaums''

Der Klassifizierungsfehler <math display="inline">R(T)</math> ist kein geeignetes Maß, um den optimalen Teilbaum (optimal subtree) zu finden, da er mit zunehmendem Baum monoton abnimmt und somit den größten Baum bevorzugt. Das Hinzufügen eines Strafterms (penalty term), der kleinere Bäume bevorzugt, führt jedoch zu einem ausgewogenen Maß (balanced measure), dessen Minimierung zum Finden des optimalen Teilbaums geeignet ist.

Sei <math display="inline">|\tilde{T}|</math> die Anzahl der Blattknoten in der Menge <math display="inline">\tilde{T}</math> und <math display="inline">\eta</math> ein Komplexitätsparameter (complexity parameter). Die Kosten-Komplexität (cost-complexity) eines Baums <math display="inline">T</math> ist durch

<math display="block">R_{\eta}(T) = R(T) + \eta |\tilde{T}|</math> definiert.

Weiterhin sei <math display="inline">T_0</math> der initiale Baum (initial tree), der durch Wachstum auf eine ausreichend große Größe erhalten wird, und <math display="inline">\hat{T}</math> die Menge der Teilbäume des Baums <math display="inline">T</math>. Dann soll der optimale Teilbaum eine minimale Kosten-Komplexität aufweisen <math display="block">\arg\min_{T \in \hat(T_0)} R_{\eta}(T) = \min_{T \in \hat(T_0)} \left(R(T) + \eta |\tilde{T}|\right).</math>

Hier begünstigt der Strafterm <math display="inline">\eta |\tilde{T}|</math> in der Zielfunktion (objective function) kleinere Bäume und der Komplexitätsparameter <math display="inline">\eta</math> gibt die Wichtigkeitsgewichtung (importance weight) der Größe des Baums an.

Es kann vorkommen, dass mehrere Teilbäume dieselbe minimale 
Kosten-Komplexität aufweisen, z. B. einer mit kleinerer Größe, aber höherem Klassifizierungsfehler. In diesem Fall wird der Teilbaum mit der kleinsten Größe bevorzugt. Daher kann der optimale Teilbaum <math display="inline">T^*(\eta)</math> als der mit der minimalen Größe unter der Teilbäume mit minimaler Kosten-Komplexität angegeben werden. Es kann wie folgt als Optimierungsproblem formuliert werden. <math display="block">\begin{aligned}
T^*(\eta) &= \arg\min_{T \in \hat{T}_0} R_{\eta}(T) = \arg\min_{T \in \hat{T}_0} \left(R(T) + \eta |\tilde{T}|\right), \\
|T^*(\eta)| &\leq T(\eta) \mathrm{\ \ }\mathrm{~fuer~alle~} \mathrm{\ \ } T(\eta) \mathrm{~mit~} T(\eta) = T^*(\eta).
\end{aligned}</math>

Da es nur endlich viele Teilbäume des Baums <math display="inline">T_0</math> gibt, ergibt <math display="inline">R_{\eta}(T^*(\eta))</math> nur für endlich viele <math display="inline">\eta</math>-s unterschiedliche Werte. Daher ist <math display="inline">R_{\eta}(T^*(\eta))</math> als Funktion von <math display="inline">\eta</math> eine stückweise Treppenfunktion mit Sprüngen (piecewise step function with jumps).

''<math display="inline">\mathrm{\ \ \ \ \ \ }</math> Weakest-Link-Cutting''

Wir erweitern die Definition der Kosten-Komplexität vom Baum auch auf Knoten. Für den Knoten <math display="inline">t \in T</math> ist seine Kosten-Komplexität als

<math display="block">R_{\eta}(t) = R(t) + \eta</math> definiert.

Die Weakest-Link-Cutting-Methode bestimmt den optimalen Teilbaum durch Durchlaufen der optimalen Teilbäume <math display="inline">R_{\eta}(T^*(\eta))</math> als Funktion von <math display="inline">\eta</math> von <math display="inline">\eta=0</math> bis <math display="inline">\eta=1</math>, indem sie den nächsten Sprungpunkt (jump point) in <math display="inline">\eta</math> rekursiv bestimmt. Das Durchlaufen der optimalen Teilbäume erfordert für jeden Knoten <math display="inline">t</math> den Vergleich von

<math display="block">\begin{aligned}
R_{\eta}(t) &= R(t) + \eta \mathrm{\ \ }\mathrm{~und~} \\
R_{\eta}(T_t) &= R(T_t) + \eta |\tilde{T}_t|.
\end{aligned}</math>

Beginnend mit <math display="inline">\eta=0</math> wissen wir bereits, dass <math display="inline">R_{0}(T_t) < R_0(t)</math> für jedes <math display="inline">t \in T_0</math>, d.h. der optimale Teilbaum für <math display="inline">\eta =0</math> ist der initiale Baum <math display="inline">T_0</math> selbst. Diese Ungleichung gilt auch für einige kleine <math display="inline">\eta</math>. Durch schrittweises Erhöhen von <math display="inline">\eta</math> wird der Punkt erreicht, an dem <math display="inline">R_{\eta}(T_t) = R_{\eta}(t)</math>, da der Koeffizient von <math display="inline">\eta</math> in <math display="inline">R_{\eta}(T_t)</math> größer als in <math display="inline">R_{\eta}(t)</math> ist. Der Wert von <math display="inline">\eta</math> an diesem Punkt kann aus der Gleichheit bestimmt werden, was zum Wert

<math display="block">\frac{R(t) - R(T_t)}{|\tilde{T}_t|-1}.</math> an diesem Gleichheitspunkt (equality point) führt.

Direkt über diesem <math display="inline">\eta</math> ist der Wert <math display="inline">R_{\eta}(T_t) > R_{\eta}(t)</math>, was bedeutet, dass das Pruning des Zweigs <math display="inline">T_t</math> zu einem Teilbaum mit geringerer Kosten-Komplexität führt. Es kann jedoch vorkommen, dass dieser Gleichheitspunkt für einen anderen Knoten früher erreicht wird, d. h. bei geringerem <math display="inline">\eta</math>. Daher tritt der erste Sprung in minimaler Kosten-Komplexität, <math display="inline">R_{\eta}(T^*(\eta))</math>, am Gleichheitspunkt mit dem kleinsten <math display="inline">\eta</math> unter den Gleichheitspunkten aller Nicht-Blattknoten (non-leaf nodes) des Baums <math display="inline">T_0</math> auf. Der Wert von <math display="inline">\eta</math> an diesem Sprungpunkt von <math display="inline">R_{\eta}(T^*(\eta))</math> wird mit <math display="inline">\eta_1</math> bezeichnet und kann wie folgt berechnet werden.

<math display="block">\eta_1 = \min_{t \in T_0\ \tilde{T}_0} \frac{R(t) - R(T_t)}{|\tilde{T}_t|-1}.</math>

Sei <math display="inline">t_1</math> der Knoten, an dem diese erste Gleichheit auftritt, mit anderen Worten <math display="block">t_1 = \arg\min_{t \in T_0\ \tilde{T}_0} \frac{R(t) - R(T_t)}{|\tilde{T}_t|-1}.</math> Then just above <math display="inline">\eta_1</math> the optimal subtree, i.e. the subtree with the smallest cost-complexity is the one, which is obtained by pruning the branch <math display="inline">T_{t_1}</math> from <math display="inline">T_0</math>, which is denoted as <math display="inline">T_1= T_0 \ T_{t_1}</math>. Repeating the gradually increase of <math display="inline">\eta</math> and the computation of the next jump point based on the cost-complexity of the actual optimal subtree, a recursive algorithm can be defined to obtain the jump points <math display="inline">\eta_i</math> and the optimal subtrees in the individual <math display="inline">\eta</math> regions. In each step the algorithm prunes the branch, whose cost-complexity becomes larger than the one of its root node at earliest in <math display="inline">\eta</math>, which can be seen as the weakest-link. That is why the algorithm is called weakest-link cutting algorithm. Its schematic operation is given in Algorithm .

Dann ist knapp über <math display="inline">\eta_1</math> der optimale Teilbaum, d. h. der Teilbaum mit der geringsten Kosten-Komplexität, derjenige, der durch Pruning den Zweig <math display="inline">T_{t_1}</math> von <math display="inline">T_0</math> erhalten wird, was als <math display="inline">T_1= T_0 \ T_{t_1}</math> bezeichnet wird. Durch Wiederholen der schrittweisen Erhöhung von <math display="inline">\eta</math> und der Berechnung des nächsten Sprungpunkts basierend auf der Kosten-Komplexität des aktuell optimalen Teilbaums kann ein rekursiver Algorithmus definiert werden, um die Sprungpunkte <math display="inline">\eta_i</math> und die optimalen Teilbäume in den einzelnen <math display="inline">\eta</math>-Regionen zu erhalten. In jedem Schritt führt der Algorithmus das Pruning den Zweig durch, dessen Kostenkomplexität in <math display="inline">\eta</math> am frühesten größer wird als die seines Wurzelknotens, der als Weakest-Link (schwächstes Glied) angesehen werden kann. Aus diesem Grund wird der Algorithmus als Weakest-Link-Cutting-Algorithmus (Algorithmus zum Beschneiden des schwächsten Glieds) bezeichnet. Seine schematische Funktionsweise ist im Algorithmus angegeben.

 
Algorithm Weakest-Link-Cutting-Algorithmus 
'''—————————————————————————————''' 
Eingabe: 
- der initiale Baum <math display="inline">T_0</math> Ausgabe: 
- Folge von Sprungpunkten <math display="inline">\eta_i</math>, <math display="inline">i \geq 1</math>, - Folge von optimalen Teilbäumen <math display="inline">T_i</math> in den einzelnen Regionen <math display="inline">[\eta_{i} - \eta_{i+1})</math>, <math display="inline">i \geq 0</math> und <math display="inline">\eta_0 =0</math>. 
'''—————————————————————————————''' 
1 Initialisierung: <math display="inline">T_{act} = T_0</math>, <math display="inline">\eta_{act} = 0</math>, <math display="inline">\eta_{next} = 0</math>, <math display="inline">\mathrm{\ \ \ \ \ }</math> <math display="inline">\eta[]=0</math>, <math display="inline">t[]=0</math>, <math display="inline">T[]=0</math>, <math display="inline">\eta[0]=0</math>, <math display="inline">T[0]=T_0</math>, <math display="inline">i=1</math> 
2 while <math display="inline">\eta_{next} < 1</math> 
3 <math display="inline">\Delta \eta = \min_{t \in T_{act}\ \tilde{T}_{act}} \frac{R(t) - R(T_t)}{|\tilde{T}_t|-1}</math> 
4 <math display="inline">\eta_{next} = \eta_{act} + \Delta \eta</math> 
5 <math display="inline">\eta[i]=\eta_{next}</math> 
6 <math display="inline">t[i] = \arg\min_{t \in T_{act}} \ \tilde{T}_{act} \frac{R(t) - R(T_t)}{|\tilde{T}_t|-1}</math> 
7 <math display="inline">T[i]= T_{act} \ T_{t[i]}</math> 
8 Update <math display="inline">T_{act} = T[i]</math>, <math display="inline">\eta_{act} = \eta_{next}</math> 
9 Inkrement <math display="inline">i</math> as <math display="inline">i=i+1</math> 
10 end 
'''—————————————————————————————''' 


=== Eigenschaften des Entscheidungsbaums ===

Ein wesentliches Merkmal des Entscheidungsbaumansatzes (decision tree approach) ist, dass der Raum seiner Eingabevektoren explizit vorgegeben ist, d. h. die Dimensionen der Eingabevektoren sind explizit bekannt. Dies ist ein wesentlicher Unterschied zu HMMs oder neuronalen Netzwerken, deren Eingabevektoren (=Featurevektoren) implizit bestimmt werden.

Nachfolgend wird eine Liste über die Vorteile des Entscheidungsbaumansatzes angeführt.

* Der Entscheidungsbaumansatz verarbeitet nicht nur Ordinalvariablen (Ordinalskala), sondern auch kategorische Variablen (Nominalskala).
* Der Entscheidungsbaumansatz ist invariant gegenüber monotonen Transformationen der Featurekomponenten als Ordinalvariablen.
* Der Entscheidungsbaumansatz liefert eine Schätzung der Fehlklassifizierungsrate für jede Klasse.
* Der Entscheidungsbaum ist robust gegenüber fehlklassifizierten Punkten (misclassified points) im Trainingsdaten und Ausreißern (outliers).
* Der Entscheidungsbaum ist leicht zu interpretieren, was ihn insbesondere in medizinischen Anwendungsszenarien attraktiv macht.


=== Random Forest ===

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Bootstrap-Aggregation - Bagging'''''

Das bisher besprochene Training ist ein deterministischer Prozess, der dieselben Parameter aus demselben Trainingsdaten ergibt. Ein anderer Ansatz besteht darin, eine zufällige Komponente in den Trainingsprozess einzuführen und mehrere Durchläufe desselben Trainingsdaten mit dem zufällig modifizierten Trainingsprozess durchzuführen. Eine solche zufällige Modifikation kann beispielsweise darin bestehen, in jedem Durchgang eine zufällig ausgewählte Teilmenge der Trainingsdaten zu nehmen und nur diese Teilmenge für das Training in diesem Durchgang zu verwenden. Die Ergebnisse nach jedem Durchgang werden angesammelt und das Endergebnis wird aus der Sammlung der Ergebnisse durch eine zweckmäßige Kombination erstellt. Hier sind die Ergebnisse beispielsweise die Parameter des Modells. Die Kombination der angesammelten Ergebnisse kann beispielweise durch Mittelwertbildung (by averaging), gewichtete Mittelwertbildung (by weighted averaging), Berechnung des Medians (computing the median) oder durch Anwendung einer Mehrheitswahl (majority voting) erfolgen. Dieser Ansatz wird als Bootstrap-Aggregation genannt oder mit dem Akronym Bagging bezeichnet.

Das Ziel von Bagging ist normalerweise, die Varianz im Ergebnis zu verringern. Die Varianz des Stichprobenmittelwerts nimmt proportional zur Anzahl der Stichproben ab und daher das Ansammlung und Mittelwertbildung mehrerer Ergebnisse eine reduzierende Wirkung auf die Varianz hat.

Bootstrap-Aggregation hat mehrere Vorteile.

* Die Mittelung über eine Sammlung trainierter Parameter reduziert Overfitting, da sie die erfasste Entwicklung zwischen den Trainingsbeispielen, die von der zugrunde liegenden Verteilung abweichen, teilweise aufhebt.
* Die Mittelung über eine Sammlung trainierter Parameter führt zu einem stabileren Endergebnis.
* Modelle mit hoher Kapazität können aufgrund der reduzierten Overfitting eine flexiblere Anpassung (fitting) erreichen.
* Die Mittelung über eine Sammlung trainierter Parameter führt zum Aufbrechen des Bias-Varianz-Kompromisses (siehe in Absatz [[#subsec:bias_variance|[subsec:bias_variance]]]), indem die Varianz neben dem gleichen Bias reduziert wird.

Bootstrap-Aggregation wurde von Leo Breiman [Breiman(1996)] entwickelt.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Random Forest'''''

Random Forest ist eine Bootstrap-Aggregation, die auf Klassifizierungs- und Regressionsbäume angewendet wird. In Random Forest werden mehrere Bäume trainiert. Während des Trainings jedes Baums wird nur eine zufällig ausgewählte Teilmenge von Komponenten des Eingabevektoren berücksichtigt, die für die Aufteilung verwendet wird.

Leo Breiman hat umfangreiche Experimente mit Random Forest durchgeführt. Er fand heraus, dass es insgesamt etwas besser abschneidet als Support Vector Machines.


== Convolutional Neural Networks für Bildverarbeitung ==

Convolutional Neural Networks (CNNs) sind eine Subklasse von KNNs, die sich für die Verarbeitung von Eingaben in Gridform, insbesondere von Bildern, eignen. Die Convolutional im Namen von CNN ergibt sich aus der Convolution Layer, die den Kernbaustein von CNN ist. Der Convolution Layer realisiert einen mathematischen Convolution (= Faltungsoperation). CNNs eignen sich besonders zum Extrahieren lokales Features und komplexerer Muster wie Texturen (textures). Hier lokal bedeutet, dass diese Features nur von den Pixeln abhängen, die sich um das betrachtete Pixel herum befinden.

Als Beispiel nehmen wir ein Feature, das durch Subtrahieren des Werts des linken Nachbarpixels vom Wert jedes einzelnen Pixels erstellt wird. Diese Funktion eignet sich zur Erkennung von Konturen, genauer gesagt von Kanten mit vertikalen Komponenten, was eine mögliche Teilaufgabe der Objekterkennung darstellt. Dies ist in Abbildung [[#fig:CNN_9.6|34]] dargestellt.

<div id="fig:CNN_9.6" class="figure">

[[Datei:CNN_9.6.jpg|460px|thumb|center|Abbildung 34: Vertikale Kantenerkennung (Quelle: [Goodfellow et al.(2016)]).]] 

</div>

Das Bild auf der rechten Seite zeigt die Anwendung des Feature zur Konturerkennung auf das Originalbild auf der linken Seite.


=== Die mathematische Convolution ===

Die stetige Version des Faltungsoperators ist ein Integral einer Multiplikation zweier Funktionen <math display="inline">x(\tau)</math> und <math display="inline">w(t-\tau)</math>, über die reellwertige Variable <math display="inline">\tau</math> als

<math display="block">s(t) = \int x(\tau) w(t-\tau) d\tau.</math>

Das resultierende Integral hängt nur von <math display="inline">t</math> ab. Solche Operatoren kommen in vielen technischen Teilgebieten vor, wie z.B. Beschreiben der Wahrscheinlichkeitsdichtefunktion der Summe zweier unabhängiger Zufallsvariablen mit den Wahrscheinlichkeitsdichtefunktionen <math display="inline">x(t)</math> und <math display="inline">w(t)</math> oder Entrauschen des Signals <math display="inline">x(t)</math> durch Bildung seines gewichteten Durchschnitts durch Anwendung von <math display="inline">t</math> abhängige Gewichte <math display="inline">w(t)</math>.

Das Argument des Integrals reicht in seiner allgemeinsten Form von <math display="inline">-\infty</math> bis <math display="inline">\infty</math>, hängt aber normalerweise vom Kontext ab. Im Beispiel pdf der Summe unabhängiger nicht negativer Zufallsvariablen geht das Integral von <math display="inline">0</math> bis unendlich, während im zweiten Beispiel <math display="inline">t</math> die Zeit darstellen kann und das Integral von <math display="inline">0</math> bis <math display="inline">t</math> geht. Werte für <math display="inline">\tau > t</math> zu haben, würde bedeuten, auch zukünftige Werte des Signals <math display="inline">x(\tau)</math> in die Berechnung des entrauschten Werts bei <math display="inline">t</math>, <math display="inline">s(t)</math>, einzubeziehen, was normalerweise im realen Kontext nicht möglich ist.

Die Convolution wird in der Regel mit einem Sternchen bezeichnet. <math display="block">s(t) = (x*w)(t) ~ \mathrm{~oder~vereinfacht~} s=x*w.</math> Die erste und die zweite Funktion, <math display="inline">x(t)</math> und <math display="inline">w(t)</math> werden als Eingabe und Kernel bezeichnet. Die Ausgabefunktion, <math display="inline">s(t)</math>, wird im neuronalen Netzwerkkontext auch als Feature-Map genannt.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Die diskrete Convolution'''''

Die diskrete Convolution ist analog definiert und kann als <math display="block">s(n) = \sum_{m=-\infty}^{\infty} x(m) w(n-m)</math> angegeben werden.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Die zweidimensionale Convolution'''''

Convolution kann auch als mehrdimensionaler Operator definiert werden. Die zweidimensionale diskrete Convolution kann wie folgt angegeben werden: <math display="block">S(n,m) = (I*K)(n,m)= \sum_{i}\sum_{j} I(i,j) K(n-i,m-j).</math>

Bei Anwenden auf ein Bild, beschreibt <math display="inline">I</math> das zweidimensionale Bild und <math display="inline">K</math> ist ein zweidimensionaler Kernel. Beide werden als zweidimensionales endliches Array dargestellt und die resultierende Matrix, <math display="inline">S(n,m)</math> wird als Ausgabematrix genannt. In diesem Fall können die Funktionen <math display="inline">I(n,m)</math> und <math display="inline">K(n,m)</math> in der oben angeführten Formel mit Ausnahme einer endlichen Menge von Punkten als Null angenommen werden. Auf diese Weise kann die unendliche Summe in der Convolution tatsächlich eine endliche Summe auch darstellen. Mehrdimensionale Arrays werden auch als Tensoren bezeichnet.

Die Convolution ist ein kommutativer Operator, was bedeutet, dass <math display="inline">S(n,m)</math> auch als <math display="block">S(n,m) = (K*I)(n,m)= \sum_{i}\sum_{j} I(n-i,m-j)K(i,j)</math> angegeben werden kann. Dies kann gezeigt werden, wenn den Umtausch <math display="inline">(n-i) \rightarrow i</math> und <math display="inline">(m-j) \rightarrow j</math> im Expression von <math display="inline">(I*K)(n,m)</math> mit Summierung über <math display="inline">-\infty</math> zu <math display="inline">\infty</math> durchgeführt werden. Dieser Ausdruck von <math display="inline">S(n,m)</math> wird auch als Form mit Kernel-Flipping bezeichnet. Normalerweise ist dies die Form, die im ML-Kontext implementiert wird.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Illustration der Convolution'''''

Die Anwendung der zweidimensionalen Convolution lässt sich anhand der Form mit Kernel-Flipping veranschaulichen. Die Gewichte werden in einem Kernelfenster angeordnet (d.h. die Elemente von K()) und auf das Bildfeld des Pixels angewendet, über denen das Kernelfenster positioniert ist. Dies ergibt einen Wert der Ausgabe. Durch horizontales und vertikales Verschieben des Kernelfensters über alle möglichen Positionen ergeben sich alle Werte des Ausgabetensors. Dies wird in Abbildung [[#fig:CNN_conv_oper|35]] dargestellt.

<div id="fig:CNN_conv_oper" class="figure">

[[Datei:CNN_conv_oper.jpg|460px|thumb|center|Abbildung 35: Illustration der 2D-Convolution anhand des Kernelfensters basierend auf der Form mit Kernel-Flipping (Quelle: [Reynolds(2021)]).]] 

</div>
Beispielsweise kann die Convolution der vertikalen Kantenerkennung, die in Abbildung [[#fig:CNN_9.6|34]] illustriert wurde, mit dem in Abbildung [[#fig:CNN_own_1|36]] dargestellten Kernelfenster realisiert werden.

<div id="fig:CNN_own_1" class="figure">

[[Datei:kernel_matrix_vertical_edge_detection.jpg|460px|thumb|center|Abbildung 36: Kernelfenster der vertikalen Kantenerkennung.]] 

</div>


=== Motivation aus rechnerischer Sicht ===

Die Anwendung der Convolution in NN ist auch aus rechnerischer Sicht vorteilhaft. Die rechnerischen Vorteile der Verwendung der Convolution in NNs zum Extrahieren lokaler Features können wie folgt aufgeführt werden:

* Sparse Connectivity (dünn besetzte Konnektivität),
* Parameter-Sharing und
* Äquivarianz zu verschieben (eqivariance to shift).

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Sparse Connectivity'''''

Lokale Features werden nur durch eine begrenzte Anzahl benachbarter Pixel beeinflusst. Bei seiner Realisierung ist jede Einheit der nächsten Layer nur mit einigen Einheiten der tatsächlichen Layer verbunden. Wenn jede Einheit der nächsten Layer nur mit <math display="inline">k</math> der <math display="inline">n</math> Einheiten der tatsächlichen Layer verbunden ist, verringert sich die erforderliche Anzahl von Operationen an jeder Einheit der nächsten Layer ebenfalls um <math display="inline">\mathcal{O}(n)</math> zu <math display="inline">\mathcal{O}(k)</math>. Dies ist eine große Errungenschaft, da <math display="inline">k</math> normalerweise mehrere Größenordnungen kleiner als <math display="inline">n</math> sein kann. Diese Sparse Connectivity, sowohl von unten als auch von oben betrachtet, ist in Abbildung [[#fig:CNN_9.2_9.3|37]] dargestellt.

<div id="fig:CNN_9.2_9.3" class="figure">

{| class="wikitable"
|-
| style="text-align: left;"| [[Datei:CNN_9.2.jpg|460px|thumb|center|]]
| style="text-align: left;"| [[Datei:CNN_9.3.jpg|460px|thumb|center|]]
|}
Abbildung 37: Sparse Connectivity von unten (Links) und von oben (Rechts) (Quelle: [Goodfellow et al.(2016)]).
</div>

In einem tiefen CNN mit mehr Hidden Layer können die tieferen Hidden Layer jedoch indirekt mit mehr Eingabeeinheiten interagieren. Dies ist in Abbildung [[#fig:CNN_9.4|38]] dargestellt.

<div id="fig:CNN_9.4" class="figure">

[[Datei:CNN_9.4.jpg|460px|thumb|center|Abbildung 38: Der rezeptive Bereich der Einheiten in tieferen Hidden Layer (Quelle: [Goodfellow et al.(2016)]).]] 

</div>

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Parameter-Sharing'''''

Die Verwendung der Convolution in NN bedeutet, dass auch für Bildfelder von mehreren Pixels dieselben Gewichte angewendet werden, siehe Abbildung [[#fig:CNN_conv_oper|35]] im Falle von 2-D-Convolution. Dies wird als Parameter-Sharing bezeichnet. In einem Fully-Connected neuronalen Netzwerkmodell wird jeder Gewichtungsparameter nur einmal verwendet, um genau eine Eingabeeinheit zu gewichten und nur einen Ausgabewert zu berechnen. Im Convolutional Neuronalen Netzen wird jedes Gewicht im Kernel für jede Eingabeeinheit verwendet.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Äquivarianz zu verschieben'''''

Die Äquivarianz von Convolution und Verschiebung bedeutet, dass der Umtausch der Reihenfolge von Convolution und Verschiebung das Ergebnis nicht ändert. Daraus folgt, dass die Anwendung desselben Convolution Kernel auf ein verschobenes Bild zur gleichen Ausgabe führt, jedoch verschoben. Daher können Teilaufgaben wie z.B. die Konturerkennung mit den gleichen Gewichtsparametern (d. h. mit den gleichen lokalen Features) im gesamten Bild unabhängig von der verschobenen Position des Objekts durchgeführt werden. Somit die Einführung eines neuen lokalen Features wegen der Verschiebung des Bildes ist nicht erforderlich. Aber die Convolution hat keine Äquivarianz zu anderen Transformationen wie der Drehung oder Skalierung eines Bildes.


=== Pooling ===

Jedes Element des Ausgabetensors der Convolution liefert einen Wert über das lokale Feature, das der Kernel an dieser Position realisiert. Pooling reduziert die Dimensionen der Ausgabe, indem die Ausgaben von Clustern neuronaler Einheiten zu einer Ausgabe kombiniert werden. Dies kann auch als eine zusammenfassende Statistik gesehen werden.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Typische Pooling Operationen'''''

Zu den typischen Pooling Operationen gehören Max-Pooling, Average-Pooling, <math display="inline">L^2</math>-Norm-Pooling oder Weighted-Average-Pooling. Max-Pooling liefert die maximale Ausgabe unter den benachbarten Positionen innerhalb eines rechteckigen Bereichs. Dies ist beispielsweise bei der Konturerkennung sinnvoll, um den schärfsten Unterschied zwischen den benachbarten Pixelwerten extrahieren, der die wahrscheinlichste Position der Kontur darstellt. Das Average-Pooling gibt den Durchschnitt der Ausgaben innerhalb eines rechteckigen Bereichs um die betrachtete Position zurück. Dies ist sinnvoll, z.B. bei Teilaufgaben wie der Einstufung eines bestimmten lokalen Feature, bei dem die räumliche Dichte der größeren Ausgabewerte dieses lokalen Feature proportional zum ausgabenden Wert ist. Ebenso bezieht sich die Norm <math display="inline">L^2</math> auch auf die Ausgaben innerhalb eines rechteckigen Bereichs um die betrachtete Position. Das Weighted-Average-Pooling berechnet gewichtete Summen unter Anwendung von Gewichtungen basierend auf der Entfernung von der betrachteten Position.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Lerninvarianz'''''

Pooling kann zum Lernen der skaleninvarianten und/oder orientierungsinvarianten Detektion von Features verwendet werden. Dies wird dadurch realisiert, dass Pooling auf separat parametrisierte Convolutionen angewendet wird. Dies ist für den Fall der Zeichenerkennung von Zahlen mit unterschiedlichen Orientierungen in Abbildung [[#fig:CNN_9.9|39]] dargestellt.

<div id="fig:CNN_9.9" class="figure">

[[Datei:CNN_9.9.jpg|460px|thumb|center|Abbildung 39: Erlernen des Erkennens des Zahlzeichens ,5“ invariant zu seiner Position (Quelle: [Goodfellow et al.(2016)]).]] 

</div>

Jede Einheit der Convolution Layer (Convolution Unit) ist parametrisiert, um eine große Ausgabe für unterschiedlich positionierte Zahlenzeichen „5“ zu liefern. Die Versorgung einer Max-Pooling-Einheit mit diesen Ausgaben führt zu einer großen Ausgabe für jedes der unterschiedlich positionierten Zahlenzeichen „5“. Basierend auf das Label „5“ kann das Modell darauf trainiert werden, das Zahlenzeichen „5“ zu erkennen, das von seiner Position abhängt.


=== Convolution Block ===

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Nichtlineare Aktivierungsfunktion'''''

Die Ausgabe jeder Convolution Unit durchläuft normalerweise eine nichtlineare Aktivierungsfunktion (nonlinear activation function), bevor sie zur Einheit der Pooling Layer (Pooling Unit) gelangt. Die nichtlineare Aktivierungsfunktion führt zumindest annähernd eine Abbildung eines bestimmten Eingabebereichs auf einen Ausgabewert (z.B. 0 oder 1) durch. Dies kann so gesehen werden, dass einige Eingabewerte gezwungen werden, sich einem vordefinierten Ausgabewert anzunähern, wodurch im Wesentlichen eine Polarisierung oder Detektorfunktionalität (detection functionality) realisiert wird. Eine der am häufigsten verwendeten nichtlinearen Aktivierungsfunktionen in CNN ist die Rectified Linear Unit, <math display="inline">ReLU(z)</math>.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Zusammensetzung eines Convolution Blocks'''''

Ein typischer Convolution Block besteht aus drei Komponenten, in der folgenden Reihenfolge.

# Convolutional Layer
# Detektor Layer (=Nichtlineare Aktivierungsfunktion)
# Pooling Layer

In Diagrammen von CNN-Architekturen werden die Nichtlineare Aktivierungsfunktion oft mit Convolutional Layer zusammen in einem gemeinsamen rechteckigen Box dargestellt. In der sogenannten komplexen Layer-Terminologie werden die drei Komponenten als „Stages“ genannt und die Komponente zusammen als Convolutional Layer.


=== Weitere typische Layers eines CNNs ===

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Flatten Layer'''''

Die Flatten Layer wird benötigt, um die Ausgabenwerten in 2D-Matrixform in einen Vektor umzuwandeln, der die Einspeisung in die Dense Layer ermöglicht. Diese Layer hat keine Parameter zu trainieren.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Dense Layer'''''

Die Dense Layer (dichte Schicht) ist eine Fully-Connected Layer (vollständig verbundene Schicht), also jede ihrer Einheiten mit der Ausgaben aller Einheiten der vorherigen Layer verbunden ist. Die Dense Layer lernt, die Features auf hohem Abstraktionsniveau aus den Convolution Blocks zu kombinieren, um die Klassifizierungsaufgabe zu erfüllen.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Dropout layer'''''

Die Dropout Layer realisiert eine so genannte Regularisierungstechnik ([https://en.wikipedia.org/wiki/Regularization_(mathematics) regularization technique]), um die Overfitting zu reduzieren. Sie wendet Dropout an, bei dem die Ausgabe zufällig ausgewählter Einheiten in jeder Trainingsphase auf Null gesetzt wird. Dies führt zu einem zufällig unterschiedlichen Menge aktiver Neuralen Einheiten in jeder Trainingsphase, was das Netzwerk dazu anregt, weniger empfindlich auf die Gewichte bestimmter Neuralen Einheiten zu reagieren und so zu einer höheren Generalisierungsfähigkeit führt.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Output layer'''''

Die Output Layer hat so viele Einheiten wie die Anzahl der Klassen in der Klassifizierungsaufgabe. Bei Klassifizierungsaufgaben mit mehreren Klassen besteht sie nur aus einer Softmax Funktion, die die Ausgabe der vorherigen Ebene in Wahrscheinlichkeiten der einzelnen Klassen umwandelt. Das Ergebnis der Klassifizierungsaufgabe, d. h. die vorhergesagte Klasse, ist dann derjenige mit der höchsten Wahrscheinlichkeit.


=== Convolution in der Praxis ===

Normalerweise wendet ein CNN viele Convolution an, um mehr Features extrahieren zu können. Um die Effizienz des Trainings zu erhalten, wird dieses als Parallelrechnung (parallel computation), z.B. durch Ausnützung der Parallelrechner-Fähigkeiten einer Grafikkarte implementiert.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Convolution on grid of vectors'''''

Bisher wurde das Eingabebild (input image) als Raster realer Werte behandelt. In der Praxis handelt es sich bei der Eingabe eines CNN jedoch eher um ein Gitter von Vektoren (grid of vectors). Beispielsweise wird jedes Pixel eines Farbbildes durch ein Vektor der Dimension 3 beschrieben, die die Intensitäten von Rot, Grün und Blau beschreiben.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Zero Padding'''''

Die Darstellung der Convolution durch Verschieben des Kernelfensters zeigt sofort, dass die Convolution mit der Kernelbreite (kernel width) <math display="inline">k</math> dazu führt, dass die Ausgabebreite(output width) mit <math display="inline">(k-1)</math> schrumpft. Dies kann vermieden werden, indem vor und nach jeder Eingabezeile einige Nullen hinzugefügt werden. Dies wird als Zero Padding (Nullauffüllung) bezeichnet. Zero Padding ermöglicht die unabhängige Steuerung der Ausgabegröße und Kernelbreite. Hier betrachten wir drei Sonderfälle der Zero Padding. Sie werden in der MATLAB-Terminologie als

* gültige Convolution (valid convolution),
* gleiche Convolution (same convolution) und
* vollständige Convolution (full convolution)

bezeichnet.

Bei einer gültigen Convolution gibt es keine Zero Padding. Es sind nur die Positionen des Kernelfensters erlaubt, an denen es vollständig im Bild enthalten ist. Somit schrumpft die Ausgabebreite bei Anwenden von jedem Convolution Layer, was die Anzahl der anwendbaren Convolution Layer begrenzt. Bei gleicher Convolution werden der Eingabe so viele Nullen hinzugefügt, womit die Ausgabe die gleiche Breite wie die Breite der Eingabe kommt. Dies bedeutet, dass zu jeder Zeile der Eingabe genau <math display="inline">(k-1)</math> Nullen hinzugefügt werden. Normalerweise werden diese Nullen vor dem linken und nach dem rechten Rand des Eingabegitters geteilt, was bedeutet, dass die Pixel am Rand des Eingabegitters Einfluss auf weniger Ausgabepixel haben als diejenigen, die sich innerhalb des Eingabegitters befinden. Die Vermeidung dieses Unterschieds motiviert die vollständige Convolution, bei der der Eingabe so viele Nullen hinzugefügt werden, dass ausreicht, um auch die Pixel am Rand des Eingabegitters <math display="inline">k</math>-mal zu besuchen. Dies wird erreicht, indem <math display="inline">(k-1)</math> Nullen sowohl vor dem linken als auch nach dem rechten Rand des Eingabegitters hinzugefügt werden. Dies führt jedoch dazu, dass die Ausgabe breiter wird, d. h. die Ausgabegröße wird um <math display="inline">(k-1)</math> größer als die Eingabegröße. Die verschiedenen Sonderfälle des Zero Padding sind in Abbildung [[#fig:CNN_9.13|40]] dargestellt.

<div id="fig:CNN_9.13" class="figure">

[[Datei:CNN_9.13.jpg|460px|thumb|center|Abbildung 40: Zero Padding für gültige (Oberes) und gleiche (Unteres) Convolution (Quelle: [Goodfellow et al.(2016)]).]] 

</div>


=== CNN Beispielarchitekturen für die Bildklassifizierung ===

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Eine einfache Musterarchitektur'''''

Eine einfache Beispielarchitektur für die Bildklassifizierung ist in Abbildung [[#fig:CNN_9.11|41]] dargestellt.

<div id="fig:CNN_9.11" class="figure">

[[Datei:CNN_9.11.jpg|460px|thumb|center|Abbildung 41: Beispielarchitektur für die Bildklassifizierung 256 x 256 x 3 (Quelle: [Goodfellow et al.(2016)]).]] 

</div>

In der ersten Convolution Stage wird 16 parallele Convolution angewendet, um die Extraktion komplexerer lokaler Features und/oder das Erlernen von Invarianzen zu ermöglichen. Diese Beispielarchitektur zeigt die Positionierung der typische Layers in einer CNN-Architektur.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Einige bekannte CNN-Architekturen'''''

Nachstehed sind einige bekannte CNN-Architekturen mit Links zu ihren Beschreibungen aufgeführt.

* [https://en.wikipedia.org/wiki/LeNet LeNet-5]
* [https://en.wikipedia.org/wiki/AlexNet AlexNet]
* [https://www.geeksforgeeks.org/vgg-16-cnn-model/ VGG-16]
* [https://en.wikipedia.org/wiki/Inceptionv3 Inception-v3]
* [https://en.wikipedia.org/wiki/Residual_neural_network ResNet-50]


== Recurrent Neural Network ==

Feedforward Neural Network werden durch gleichzeitige Eingabe (Input) gespeist. Im Gegensatz dazu sind Recurrent Neural Networks - RNN (rekurrentes neuronales Netzwerk) in der Lage, sequentielle Eingaben zu verarbeiten. Es eignet sich für Aufgaben, bei denen es um Eingaben mit sequentiellem Charakter geht, wie z.B. Text, gesprochene Sprache. Die sequentielle Natur der Eingabe spiegelt sich oft in ihrer zeitlichen Natur wider.

Ein Recurrent Neural Network ist ein neuronales Netzwerk, dessen Netzwerkarchitektur einen Zyklus aufweist, d. h. der Wert einer Unit in einer Layer des Netzwerks hängt von ihrer eigenen vorherigen Ausgabe als Eingabe ab. Diese Abhängigkeit ermöglicht, dass die Ausgabe des Recurrent Neural Network aufgrund seiner wiederkehrenden Verbindungen von Hunderten (theoretisch unendlich vielen) vorherigen Input Units abhängt. Diese langfristige Abhängigkeit von der Zeit ist das Novum des RNN, das neue Möglichkeiten für das Recurrent Neural Network eröffnet, beispielsweise wenn es zur Sprachmodellierung verwendet wird.

Der Zyklus in der Netzwerkarchitektur eines Recurrent Neural Network macht es leistungsstark, erschwert jedoch die Schlussfolgerung seiner Ausgabe aus seinen Eingaben und macht auch das Training des Netzwerks komplizierter.


=== Einfaches Recurrent Neural Network ===

Wir wollen uns nur mit einer eingeschränkten Unterklasse der allgemeinen Klasse Recurrent Neural Network befassen, den sogenannten Elman Networks (Elman-Netzwerken) [Elman(1990)] oder einfachen Recurrent Neural Network. Diese dient auch als Basis für weitere Architekturen von Recurrent Neural Network, wie z.B. das LSTM (siehe Unterabschnitt [[#subsubsec:LSTM|4.4.4]]). Von nun an werden wir dieses einfache Recurrent Neural Network als Recurrent Neural Network oder RNN bezeichnen.

Wir werden den Index <math display="inline">t</math> verwenden, um die Zeit des gegebenen Vektors darzustellen, wie z.B. <math display="inline">{\bf x}_t</math> repräsentiert den Eingabevektor zum Zeitpunkt <math display="inline">t</math> oder <math display="inline">{\bf h}_t</math> repräsentiert den Ausgabevektor der einzigen Hidden Layer zum Zeitpunkt <math display="inline">t</math>. Die Architektur des RNN ist in Abbildung [[#fig:RNN_9.1|42]] dargestellt ([Elman(1990)]).

<div id="fig:RNN_9.1" class="figure">

[[Datei:RNN_9.1.jpg|460px|thumb|center|Abbildung 42: Die Architektur des einfachen Recurrent Neural Network (Quelle: [JurafskyMartin(2023)]).]] 

</div>

Wie in Abb. 9.1 zu sehen ist, liegt das Wesentliche des RNN in der wiederkehrenden Verknüpfung vom Ausgang der Hidden Layer mit dem Eingang der Hidden Layer, der in der gestrichelten Linie dargestellt ist. Die Ausgabe der Hidden Layer zum vorherigen Zeitpunkt realisiert einen Speicher und kann als Kontext angesehen werden, der Informationen über die Verarbeitung früherer Eingaben kodiert. Noch wichtiger ist, dass im RNN keine Längenbeschränkung für diesen Kontext auferlegt wird. Im Prinzip kann dieser Kontext Informationen bis zum Anfang der Eingabesequenz (input sequence) erfassen.

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Vorwärtsinferenz (Forward Inference)'''''

Der Ausgabewert der Hidden Layer zum Zeitpunkt <math display="inline">t-1</math> wird bei der Berechnung des Ausgabewerts der Hidden Layer zum Zeitpunkt <math display="inline">t</math> einbezieht, indem ein neuer Satz von Gewichten darauf angewendet wird, die durch die Matrix <math display="inline">{\bf U}</math> dargestellt werden. Somit kann die zeitabhängige Berechnung des RNN wie folgt angegeben werden:

<math display="block">\begin{aligned}
& {\bf h}_t = f_h({\bf U}{\bf h}_{t-1} + {\bf W}{\bf x}_{t})\\
& {\bf y}_t = {\bf F}_o({\bf V}{\bf h}_{t}).
\end{aligned}</math>

Die Aktivierungsfunktion der Output Layer <math display="inline">{\bf F}_o({\bf z}_{t})</math> ist normalerweise eine Softmax Funktion, also eine Vektorwertige Funktion. Das Hinzufügen der Zeitabhängigkeit zur Beschreibung von RNN scheint dieses Netzwerk komplexer zu machen, aber tatsächlich kann seine Berechnung durch die Einführung des Vektors <math display="inline">{\bf h}_{t-1}</math> auf eine Berechnung eines entprechenden Feedforward Network zurückgeführt werden. Dies ist in Abbildung [[#fig:RNN_9.2|43]] dargestellt.

<div id="fig:RNN_9.2" class="figure">

[[Datei:RNN_9.2.jpg|460px|thumb|center|Abbildung 43: Die Einfaches Recurrent Neural Network, dargestellt als entsprechendes Feedforward Network (Quelle: [JurafskyMartin(2023)]).]] 

</div>

Der sequentielle Charakter des RNN kann durch zeitliches Ausrollen hervorgehoben werden. Dies ist in Abbildung [[#fig:RNN_9.4|44]] dargestellt.

<div id="fig:RNN_9.4" class="figure">

[[Datei:RNN_9.4.jpg|460px|thumb|center|Abbildung 44: Die Einfaches Recurrent Neural Network, dargestellt im zeitlichen Ablauf (Quelle: [JurafskyMartin(2023)]).]] 

</div>

'''''<math display="inline">\mathrm{\ \ \ \ }</math> Training'''''

RNN zu trainieren bedeutet, die Parameter der Gewichtsmatrizen <math display="inline">{\bf W}</math>, <math display="inline">{\bf U}</math> und <math display="inline">{\bf V}</math> zu lernen. Aufgrund der wiederkehrenden Struktur des Netzwerks sind vor der Gestaltung des Trainings folgende Überlegungen notwendig.

* Die Berechnung des Loss zum Zeitpunkt <math display="inline">t</math> erfordert die Ausgabe der Hidden Layer zum Zeitpunkt <math display="inline">t-1</math>.
* Die Ausgabe der Hidden Layer zum Zeitpunkt <math display="inline">t</math> beeinflusst nicht nur die Ausgabe des Netzwerks zum Zeitpunkt <math display="inline">t</math>, sondern auch die Ausgabe der Hidden Layer zum Zeitpunkt <math display="inline">t+1</math>. 
<math display="inline">\Leftrightarrow</math> Die Berechnung des Fehlers am Ausgang der Hidden Layer zum Zeitpunkt <math display="inline">t</math> erfordert die Kenntnis seiner Auswirkung auf <math display="inline">{\bf y}_{t}</math> und alle <math display="inline">{\bf y}_{t+i}</math> und <math display="inline">{\bf h}_{t+i}</math>, <math display="inline">i \geq 1</math>.

Daraus folgt, dass das Training von RNN das Ausrollen des Recurrent Neural Network in ein Feedforward Network erfordert und das Training dann auf diesem Feedforward Network auf übliche Weise durchgeführt werden kann, einschließlich der folgenden zwei Durchgänge:

* Vorwärtsinferenz, Berechnung von <math display="inline">{\bf h}_{t}</math> und <math display="inline">{\bf y}_{t}</math> und Speichern von <math display="inline">{\bf h}_{t}</math> für die Verwendung des nächsten Zeitschritts <math display="inline">t \geq 1</math> sowie die Akkumulation des Loss bei jedem Zeitschritt.
* Rückwärtsdurchlauf (backward pass), um den Fehler der Ausgabe der Hidden Layer für jeden rekursiven Rückschritt zu berechnen und zu speichern sowie den Gradient zu berechnen.

Dieser Ansatz zum Training von RNN wird als Backpropagation Through Time [Werbos(1974)] bezeichnet.

Bei Anwendungen mit längeren Eingabesequenzen, wie z.B. Streaming, Spracherkennung, muss das Ausrollen auf Segmente mit fester Länge beschränkt werden, da das Ausrollen der gesamten Eingabesequenz praktisch nicht möglich ist.


=== Stacked RNN ===

Stacked RNN (gestapeltes RNN) ist eine Erweiterung von RNN, bei der die gesamte Ausgabesequenz eines RNN als Eingabesequenz für ein nächstes RNN verwendet wird. Die Architektur des Stacked RNN ist in Abbildung [[#fig:RNN_9.10|45]] dargestellt.

<div id="fig:RNN_9.10" class="figure">

[[Datei:RNN_9.10.jpg|460px|thumb|center|Abbildung 45: Architektur des Stacked RNN (Quelle: [JurafskyMartin(2023)]).]] 

</div>

Stacked RNNs haben im Allgemeinen höhere Fähigkeiten als ein RNN. Dies liegt daran, dass allgemein davon ausgegangen wird, dass jede Layer eine andere Abstraktionsebene einführt. Allerdings steigt der Zeit- und Ressourcenbedarf des Trainings mit der Anzahl der Layer schnell an. Die optimale Anzahl der Layer hängt von den Anforderungen der Anwendung ab.


=== Bidirektionales RNN ===

Die Idee des bidirektionalen RNN [SchusterPaliwal(1997)] besteht darin, nicht nur die Kontextinformationen aus dem linken Teil der Folge von Eingabevektoren (linker Kontext), sondern auch aus dem rechten Teil davon zu verwenden. In Anwendungen, in denen die Sequenz keine Zeit darstellt und die gesamte Eingabesequenz verfügbar ist, ist diese Architektur sinnvoll. Es stellt sicher, dass Kontokontextinformationen nicht nur von links, sondern auch von rechts genutzt werden, was z. B. die Leistung der Klassifizierungsaufgabe verbessert.

Im RNN repräsentiert die Ausgabe der Hidden Layer zum Zeitpunkt <math display="inline">t</math> die Kontextinformationen aus dem linken Teil der Folge von Eingabevektoren. Dies kann als Vorwärts-RNN angesehen werden, da die Hidden Layer die Informationen über die Eingabevektoren von links nach rechts weitergibt. Ein ähnlicher Rückwärts-RNN kann eingerichtet werden, dessen Hidden Layer die Informationen über die Eingabevektoren von rechts nach links weitergibt. Somit können die Ausgabevektoren der Vorwärts- und Rückwärts-RNNs, als Hidden Layers, zum Zeitpunkt <math display="inline">t</math>, <math display="inline">{\bf h}_{t}^f</math> und <math display="inline">{\bf h}_{t}^b</math> als

<math display="block">\begin{aligned}
& {\bf h}_{t}^f = RNN_{forward}({\bf x}_{1}, \ldots, {\bf x}_{t})\\
& {\bf h}_{t}^b = RNN_{backward}({\bf x}_{t}, \ldots, {\bf x}_{n})
\end{aligned}</math> beschrieben werden, wobei <math display="inline">n</math> ist die Anzahl der Eingabevektoren in der Eingabesequenz. Die Parametergewichte des Rückwärts-RNN können durch das Training eines RNN auf einer umgekehrten Eingabesequenz erlernt werden.

Dann werden die gesamten Zustands- oder Kontextinformationen zum Zeitpunkt <math display="inline">t</math> zusammengestellt, indem sowohl die linken als auch die rechten Kontextinformationen kombiniert werden. Dies geschieht durch die Kombination der Vektoren <math display="inline">{\bf h}_{t}^f</math> und <math display="inline">{\bf h}_{t}^b</math>, die die linken und die rechten Kontextinformationen darstellen. Mögliche Kombinationsvarianten sind Verkettung (concatenation), Multiplikation oder elementweise Addition. Beispielsweise kann durch Anwenden der Verkettung der Vektor <math display="inline">{\bf h}_{t}</math>, der die gesamten Kontextinformationen darstellt, als

<math display="block">{\bf h}_{t} = [{\bf h}_{t}^f {\bf h}_{t}^b],</math> angegeben werden, wobei <math display="inline">[{\bf a} {\bf b}]</math> für die Verkettung der Vektoren <math display="inline">{\bf a}</math> und <math display="inline">{\bf b}</math> steht. Ein solches bidirektionales RNN mit Verkettung ist in Abbildung [[#fig:RNN_9.11|46]] dargestellt.

<div id="fig:RNN_9.11" class="figure">

[[Datei:RNN_9.11.jpg|460px|thumb|center|Abbildung 46: Bidirektionales RNN mit separat trainierten Modellen in Vorwärts- und Rückwärtsrichtung (Quelle: [JurafskyMartin(2023)]).]] 

</div>


=== Das LSTM ===

Eine Einschränkung von RNN besteht darin, dass es für Aufgaben, bei denen Informationen berücksichtigt werden müssen, die weit vom aktuellen Index <math display="inline">t</math> entfernt sind, nicht effektiv ist. Der Grund dafür ist, dass die in <math display="inline">{\bf h}_{t}</math> kodierten Informationen eher lokal sind und somit den Einfluss näherer Teile der Eingabesequenz widerspiegeln.

Um dieses Problem zu lösen, wurden kompliziertere RNN-Architekturen entworfen, die explizit diejenige Informationsteile steuern, die vergessen beziehungsweise für die zukünftige Verwendung gespeichert werden sollen, und diese Steuerung dynamisch über die Zeit durchführen. Eine solche RNN-Architektur ist das neuronale Netzwerk Long Short-Term Memory (LSTM) 
Das LSTM wird als Hidden Unit realisiert. Es führt zu jedem Zeitpunkt <math display="inline">t</math>, einen Kontextvektor, <math display="inline">{\bf c}_{t}</math>, ein. Der Kontextvektor wird zur Maskierung bei der Berechnung der tatsächlichen Ausgabe der Hidden Unit zum Zeitpunkt <math display="inline">t</math>, <math display="inline">{\bf h}_{t}</math> verwendet. Andererseits wird der Kontextvektor bei jedem Zeitschritt aktualisiert, d. h. <math display="inline">{\bf c}_{t}</math> wird aus <math display="inline">{\bf c}_{t-1}</math> berechnet. Während dieses Updates wird

* ein Teil des Kontextvektors <math display="inline">{\bf c}_{t-1}</math> durch Maskierung mit dem Forget Gate <math display="inline">{\bf f}_{t}</math> gelöscht (welches <math display="inline">{\bf k}_{ t}</math> resultiert) und
* ein Teil der eigentlichen Information <math display="inline">{\bf g}_{t}</math>, die aus <math display="inline">{\bf h}_{t-1}</math> und <math display="inline">{\bf x}_{t}</math> wie üblich extrahiert, wird durch Maskierung mit dem Add Gate <math display="inline">{\bf i}_{t}</math> bewahrt (welches <math display="inline">{\bf j}_{t}</math> resultiert) und
* die Summe von <math display="inline">{\bf k}_{t}</math> und <math display="inline">{\bf j}_{t}</math> gebildet um den aktualisierten Kontextvektor <math display="inline">{\bf c}_{t}</math> anzugeben.

Die elementweise Multiplikation (auch als Hadamard-Produkt von Vektoren bezeichnet) wird mit <math display="inline">\odot</math> bezeichnet, und die Sigmoid Aktivierungsfunktionen werden zur Realisierung der Funktionalität der Maskierung verwendet. Das Sigmoid wird aufgrund seiner Eigenschaft ausgewählt, indem seine Eingabe entweder in Richtung <math display="inline">0</math> oder <math display="inline">1</math> zu werfen. Genauer gesagt werden die oben genannten Vektoren, wie folgt, berechnet.

# Löschen eines Teils von <math display="inline">{\bf c}_{t-1}</math> durch Maskieren mit dem Forget Gate <math display="inline">{\bf f}_{t}</math> <math display="inline">\Rightarrow</math> <math display="inline">{\bf k}_{t}</math> <math display="block">\begin{aligned}
& {\bf f}_{t} = \sigma({\bf U}_{f}{\bf h}_{t-1} + {\bf W}_{f}{\bf x}_{t}) \\
& {\bf k}_{t} = {\bf c}_{t-1} \odot {\bf f}_{t}.

\end{aligned}</math>
# Extrahieren der tatsächlichen Informationen <math display="inline">{\bf g}_{t}</math> aus <math display="inline">{\bf h}_{t-1}</math> und <math display="inline">{\bf x}_{t}</math> sowie Bewahren eines Teils davon durch Maskieren mit das Add Gate <math display="inline">{\bf i}_{t}</math> <math display="inline">\Rightarrow</math> <math display="inline">{\bf j}_{t}</math> <math display="block">\begin{aligned}
& {\bf g}_{t} = tanh(({\bf U}_{g}{\bf h}_{t-1} + {\bf W}_{g}{\bf x}_{t})
& {\bf i}_{t} = \sigma({\bf U}_{i}{\bf h}_{t-1} + {\bf W}_{i}{\bf x}_{t}) \\
& {\bf j}_{t} = {\bf g}_{t} \odot {\bf i}_{t}.

\end{aligned}</math>
# Zusammenstellen des aktualisierten Kontextvektors durch Summieren von <math display="inline">{\bf k}_{t}</math> und <math display="inline">{\bf j}_{t}</math> <math display="inline">\Rightarrow</math> <math display="inline">{\bf c}_{t}</math> <math display="block">\begin{aligned}
& {\bf c}_{t} = {\bf k}_{t} + {\bf j}_{t}.

\end{aligned}</math>
# Berechnen von <math display="inline">{\bf o}_{t}</math> auf übliche Weise aus <math display="inline">{\bf h}_{t-1}</math> und <math display="inline">{\bf x}_{t}</math> sowie erstellen den Ausgabevektor der Hidden Unit durch Maskieren von <math display="inline">{\bf o}_{t}</math> mit dem tatsächlichen Kontextvektor <math display="inline">{\bf c}_{t}</math> <math display="inline">\Rightarrow</math> <math display="inline">{\bf h}_{t}</math> <math display="block">\begin{aligned}
& {\bf o}_{t} = \sigma({\bf U}_{o}{\bf h}_{t-1} + {\bf W}_{o}{\bf x}_{t}) \\
& {\bf h}_{t} = {\bf o}_{t} \odot tanh({\bf c}_{t}).

\end{aligned}</math>

Die gesamte Berechnung der neuronalen LSTM-Einheit ist in Abbildung [[#fig:RNN_9.13|47]] dargestellt.

<div id="fig:RNN_9.13" class="figure">

[[Datei:RNN_9.13.jpg|460px|thumb|center|Abbildung 47: Die Berechnungsarchitektur einer neuronalen LSTM-Einheit (Quelle: [JurafskyMartin(2023)]).]] 

</div>

Der Vergleich der Eingabe- und Ausgabeschnittstellen der neuronalen Einheiten FNN, RNN und LSTM ist in Abbildung [[#fig:RNN_9.14|48]] zu sehen.

<div id="fig:RNN_9.14" class="figure">

[[Datei:RNN_9.14.jpg|460px|thumb|center|Abbildung 48: Neuronale Einheiten von (a) FNN, (b) RNN und (c) LSTM (Quelle: [JurafskyMartin(2023)]).]] 

</div>