WEBVTT 00:00.440 --> 00:01.300 Okay, good morning. 00:01.560 --> 00:04.780 Welcome to another lecture on organic computing. 00:05.080 --> 00:11.040 We are in the chapter on machine learning and have looked at many 00:11.040 --> 00:12.380 different things there. 00:13.540 --> 00:19.680 In particular, we have looked at learning classifier systems, have 00:19.680 --> 00:24.760 looked at all the different parts there on how to determine match 00:24.760 --> 00:27.780 sets, action sets, how to learn. 00:27.900 --> 00:33.980 You have also learned quite a bit about that in the tutorials. 00:34.180 --> 00:37.960 You get more chances to go deeper into that. 00:38.560 --> 00:43.060 We briefly looked at genetic algorithms or evolutionary algorithms. 00:43.060 --> 00:49.440 I showed you the different ways how we can actually implement or 00:49.440 --> 00:52.820 design the different phases, how we can represent, how we can 00:56.940 --> 00:59.300 perform all the different operations. 00:59.540 --> 01:04.500 How we can represent was this here, different types, linear or in a 01:04.500 --> 01:08.820 problem -specific way, genotypes that have structure more than just a 01:08.820 --> 01:09.720 linear sequence. 01:10.540 --> 01:14.020 We looked at ways of selecting. 01:15.360 --> 01:18.340 This must have been selection mechanisms. 01:18.890 --> 01:21.220 The first ones were, oh, this year. 01:21.280 --> 01:24.100 This year was roulette wheel selection. 01:24.680 --> 01:29.020 Then we looked at tournament selection, rank-based selection, and so 01:29.020 --> 01:29.320 on. 01:29.820 --> 01:38.540 We looked at representation for the different ways or the different 01:38.540 --> 01:44.700 types of representations, bit string or real value representation. 01:44.900 --> 01:48.220 I showed you some standard methods there. 01:49.140 --> 01:56.400 We looked at also at, again, how you can actually perform the 01:56.400 --> 02:00.760 operations on tree-shaped representations, which are quite common in 02:00.760 --> 02:01.700 genetic programming. 02:03.160 --> 02:07.580 I then showed you something on, yeah, a few more things on LCS. 02:07.900 --> 02:13.440 In particular, I showed you something on covering. 02:14.180 --> 02:21.460 Then we went on to rule combining, a subject that I included now into 02:21.460 --> 02:27.540 this chapter, which was designed by one of my PhD students. 02:29.380 --> 02:36.260 These different steps to find out which rules can be combined in order 02:36.260 --> 02:42.340 to get more general rules and, at the same time, reduce the number of 02:42.340 --> 02:43.900 rules in the population. 02:44.780 --> 02:47.820 This was the overview, how that was done. 02:47.980 --> 02:49.460 We looked at that last time. 02:49.560 --> 02:54.040 You will also have a chance to look at that in the tutorials and maybe 02:54.040 --> 02:56.360 revisit that at some other places. 02:57.400 --> 03:05.300 Then we also looked at the performance of these methods and saw that 03:05.300 --> 03:11.840 it really results in better performance, better accuracy, higher 03:11.840 --> 03:15.460 accuracy and quality of the learning system. 03:16.180 --> 03:24.860 Also for the benchmark problems, multiplexer and some agent movements 03:24.860 --> 03:26.720 in two-dimensional meshes. 03:28.880 --> 03:32.240 That was some remarks on rule combining. 03:32.640 --> 03:36.760 Then we started with neural networks. 03:37.140 --> 03:43.740 We looked at the standard ways of defining a neural network. 03:43.920 --> 03:48.160 I showed you some simple examples, which were very simple, for 03:48.160 --> 03:50.080 learning linear functions. 03:50.420 --> 03:56.000 Then we saw that for learning the XOR function, we actually need a 03:56.000 --> 03:56.580 hidden layer. 03:57.020 --> 04:00.300 Without a hidden layer, you cannot learn a function like that, because 04:00.300 --> 04:05.400 with just one layer, you can only learn linear functions. 04:06.340 --> 04:08.620 That shows that we need this hidden layer. 04:12.540 --> 04:15.280 This would be the first slide for today. 04:16.540 --> 04:19.640 If we want to design neural networks, we have to find out how to do 04:19.640 --> 04:19.840 that. 04:21.120 --> 04:24.740 There are two principally different ways of doing that. 04:25.380 --> 04:29.060 We have to find out how to assign the weights to the connections 04:29.060 --> 04:31.400 between one layer and the next layer. 04:32.160 --> 04:34.260 For that, we have different methods. 04:34.540 --> 04:42.560 We have supervised training and we have unsupervised training. 04:43.500 --> 04:50.160 I will show you just a very simple view on what is happening there in 04:50.160 --> 04:51.060 these different ways. 04:51.220 --> 04:55.920 I don't go into very many details. 04:56.180 --> 05:01.000 One example of how you would do the training. 05:01.220 --> 05:04.460 If you would like to train a neural network, you would like to find 05:04.460 --> 05:09.500 out or to determine the weights of the network, such that it actually 05:09.500 --> 05:11.300 comes up with the appropriate result. 05:12.660 --> 05:17.260 You need some training data where you look at how the system or how 05:17.260 --> 05:20.380 the network performs with respect to those weights. 05:22.040 --> 05:23.340 With some initial weights. 05:23.600 --> 05:27.400 And if you find out it does not come up with the correct result, you 05:27.400 --> 05:28.660 have to modify the weights. 05:29.340 --> 05:31.420 There are many different ways of assigning the weights. 05:31.500 --> 05:32.660 You can do that directly. 05:33.800 --> 05:36.720 There's one method which is called backpropagation, which I will 05:36.720 --> 05:39.700 indicate a little bit on one of the next slides. 05:40.660 --> 05:44.140 But you could also do it, for example, with an evolutionary algorithm. 05:44.540 --> 05:51.000 Just design, just explore the search space of weights for appropriate 05:51.000 --> 05:54.460 selection of weights and then you could find out how well they 05:54.460 --> 05:55.180 actually perform. 05:55.840 --> 06:00.620 So there have been approaches for evolutionary generation of neural 06:00.620 --> 06:01.080 networks. 06:02.220 --> 06:08.360 And so this typical example is you would like to find out or to detect 06:08.360 --> 06:12.460 certain letters on some writing pad. 06:13.020 --> 06:14.460 And here you see some examples. 06:14.680 --> 06:17.600 These could be some training examples. 06:18.040 --> 06:21.820 So for this data, the result should be A. 06:22.440 --> 06:26.860 So you have to find out appropriate weights such that if you put in 06:26.860 --> 06:32.300 the 90 inputs into these, like the 90 different pixels that you have 06:32.300 --> 06:40.600 here in that area, indicating 0 or 1, whether it is highlighted or 06:40.600 --> 06:45.120 not, you have to find out how to assign the weights such that you 06:45.120 --> 06:45.900 actually get A. 06:46.320 --> 06:50.560 And certainly not just A, but also you need appropriate learning 06:50.560 --> 06:54.140 patterns for all the different letters that we have in the alphabet. 06:55.700 --> 06:59.320 In a more simplified way, you could say, okay, you can also, you would 06:59.320 --> 07:04.260 like to recognize then afterwards you have some real examples where 07:04.260 --> 07:07.820 you maybe take a pen and write on that field. 07:07.980 --> 07:12.440 And then you should be able from the training set to generalize or the 07:12.440 --> 07:18.100 neural network should be able to generalize or the weights have to be 07:18.100 --> 07:22.780 designed such that those patterns will also be detected. 07:23.760 --> 07:27.200 And certainly that will be slightly different from what you have had 07:27.200 --> 07:28.500 in the training examples. 07:28.860 --> 07:32.820 And so you have to look at what is actually the appropriate 07:32.820 --> 07:43.040 determination or the appropriate design of training samples and test 07:43.040 --> 07:47.320 samples such that you get some idea of how accurate actually your 07:47.320 --> 07:50.240 network has been designed. 07:50.980 --> 07:54.600 So there's a lot of theory around that, many different approaches to 07:54.600 --> 07:54.920 that. 07:55.060 --> 07:58.860 You get tools for doing that, software packages, how you can actually 07:58.860 --> 08:00.640 design neural networks. 08:01.640 --> 08:05.900 And one standard way of doing that is the backpropagation algorithm. 08:06.880 --> 08:11.960 The backpropagation algorithm, in very simple words, does the 08:11.960 --> 08:12.260 following. 08:13.320 --> 08:17.560 The idea is you want to get the weights of a neural network using some 08:17.560 --> 08:18.260 training data. 08:18.520 --> 08:22.320 You start with some arbitrary set of weights, just some random 08:22.320 --> 08:23.320 assignment of weights. 08:24.200 --> 08:27.220 And then you apply the inputs of a training sample. 08:28.080 --> 08:34.580 You have a training set and you run all the training examples on your 08:34.580 --> 08:35.460 neural network. 08:35.740 --> 08:39.560 You calculate or you obtain the outputs and then you compute the 08:39.560 --> 08:44.140 error, the deviation from the expected output. 08:45.440 --> 08:53.160 So you observe the output, you calculate the error, and then by 08:53.160 --> 08:59.140 backpropagation, that's what backpropagation is about, you would like 08:59.140 --> 09:05.260 to or you look for the optimum set of weights which would minimize the 09:05.260 --> 09:06.440 error. 09:07.220 --> 09:13.320 And so you have a certain error here, you go back to those weights, 09:13.400 --> 09:20.480 you modify the weights, you choose different weights such that you 09:20.480 --> 09:21.760 minimize the error here. 09:22.280 --> 09:26.900 And then you get deviations for the outputs of those nodes. 09:27.580 --> 09:34.040 And then again you can backpropagate and modify the weights that led 09:34.040 --> 09:34.880 to those nodes. 09:35.480 --> 09:39.320 And so in this way you have a backpropagation algorithm which 09:39.320 --> 09:44.060 iteratively will modify the weights on the different layers in that 09:44.060 --> 09:44.700 neural network. 09:45.320 --> 09:50.100 This is based on some assumptions on how you can actually deal with 09:50.100 --> 09:50.420 that. 09:51.180 --> 09:56.480 It's just a mathematical optimization approach and it works quite 09:56.480 --> 09:56.880 well. 09:57.300 --> 10:05.180 Just to mention, there is one variant which is called rprop which is a 10:05.180 --> 10:08.540 faster way of the standard backpropagation algorithm. 10:08.680 --> 10:13.780 So if you look for neural network design and you find the standard 10:13.780 --> 10:18.080 backpropagation algorithm, you should instead look for rprop which is 10:18.080 --> 10:23.300 a much faster and more adequate way of doing backpropagation, which 10:23.300 --> 10:29.020 actually was designed here in the Faculty of Informatics at Karlsruhe. 10:29.620 --> 10:33.760 It's not the reason why I advertise that, but it's actually the better 10:33.760 --> 10:34.540 version of that. 10:35.080 --> 10:37.640 So I don't go into those details. 10:37.980 --> 10:43.980 This would be a subject of another course on machine learning 10:43.980 --> 10:44.560 algorithms. 10:45.120 --> 10:48.400 I just wanted to indicate that here you would just look at the errors. 10:48.940 --> 10:54.120 You would go back one step, modify or optimize the weights that led to 10:54.120 --> 10:54.880 that node. 10:55.500 --> 10:59.500 This way you get a deviation on the next layer, use that to go to the 10:59.500 --> 11:01.980 next to the previous layer and so on. 11:02.180 --> 11:06.780 And then you have to run that set of... like you have a certain set of 11:06.780 --> 11:09.780 training data and then you run that again. 11:10.600 --> 11:15.600 Again you will have some deviations and in this way successively you 11:15.600 --> 11:22.020 will modify the weights and this usually converges to a more 11:22.020 --> 11:22.980 appropriate setting. 11:23.400 --> 11:26.900 There are many questions around that, like what is the appropriate 11:26.900 --> 11:31.980 number of rounds that you have to do, how accurate actually should 11:31.980 --> 11:33.540 that be, if the training set... 11:34.960 --> 11:42.380 or if you learn too much, if it's... so for example, if you have a 11:42.380 --> 11:44.820 certain function that you would like to learn or you have a certain 11:44.820 --> 11:52.600 number of nodes here and if what you learn is... like the simplest way 11:52.600 --> 11:56.700 of learning this would be to have a linear function, which very often 11:56.700 --> 11:57.540 would be very bad. 11:58.160 --> 12:04.220 If you have... like the higher the degree of the learning function is, 12:04.340 --> 12:14.360 like the embedded degree of the approximation of that function, it 12:14.360 --> 12:19.060 might be that you end up with something like this. 12:19.820 --> 12:21.240 Oops, that's not correct. 12:21.960 --> 12:29.240 So let's assume we have something like this and so if you have a... if 12:29.240 --> 12:35.500 you learn a very high degree polynomial, this might fit perfectly to 12:35.500 --> 12:41.060 the training data, but maybe that the test data later on is more in 12:41.060 --> 12:41.900 those areas. 12:42.760 --> 12:46.400 And so it might be that you have overlearned your... 12:47.380 --> 12:51.280 or you have learned a too complex function and it would have been 12:51.280 --> 12:54.380 better to have something which is more like this. 12:55.340 --> 12:59.420 And so this is some problem which I just mentioned briefly. 13:00.440 --> 13:00.880 It's a... 13:01.320 --> 13:04.700 like the design of a neural network is not very simple. 13:04.840 --> 13:10.860 There are many tools supporting to do that and so that's how you would 13:10.860 --> 13:11.740 approach that. 13:12.160 --> 13:16.920 You go certainly read about how to design neural networks and then you 13:16.920 --> 13:21.800 would look for some tools which usually also have tutorials on how to 13:21.800 --> 13:22.280 use that. 13:22.700 --> 13:25.240 So I will not go too much into the details here. 13:25.700 --> 13:29.840 So this is what... just a remark on the supervised neural networks. 13:30.300 --> 13:34.400 The main advantage is that once you have trained them, you can use 13:34.400 --> 13:34.640 them. 13:34.880 --> 13:38.540 And so if you have a stable environment and you want to learn certain 13:38.540 --> 13:42.360 patterns and you know that this is a stable thing, you always learn 13:42.360 --> 13:48.720 those patterns and then you train your network and then you can use 13:48.720 --> 13:49.000 it. 13:50.320 --> 13:53.660 But if you use it, you don't learn anymore. 13:54.340 --> 13:58.160 So they are robust classification and learning methods for static 13:58.160 --> 13:59.460 problems and environments. 14:00.480 --> 14:05.220 In organic computing, we usually have quite dynamic environments. 14:06.500 --> 14:11.200 And so if you would notice all of a sudden this does not work anymore, 14:11.820 --> 14:15.480 you have to run a new learning period for those networks. 14:15.580 --> 14:18.360 You again need training data, appropriate training data and things 14:18.360 --> 14:18.800 like that. 14:19.520 --> 14:24.800 And so for dynamic environments, neural networks, back propagation 14:24.800 --> 14:30.740 neural networks are not the adequate way of actually approaching that 14:30.740 --> 14:31.260 problem. 14:31.540 --> 14:34.900 So one idea is to use unsupervised neural networks. 14:35.660 --> 14:41.220 And so they don't need training data, they adjust to the current 14:41.220 --> 14:41.880 situation. 14:42.880 --> 14:47.600 And I will show you a simple example of that. 14:47.700 --> 14:52.000 One standard example for unsupervised training, which is a self 14:52.000 --> 14:53.240 -organizing map. 14:53.580 --> 14:58.360 This is a very old standard way of doing unsupervised learning. 14:59.020 --> 15:02.700 And I will give you an example how that actually is working. 15:03.380 --> 15:09.760 So here we have a network of neurons or of some cells of nodes. 15:10.400 --> 15:15.340 You could call them neurons, but it's a slightly different way of of 15:15.340 --> 15:16.760 designing such a network. 15:16.980 --> 15:23.520 So here every node has or every neuron has a weight vector, some 15:23.520 --> 15:26.600 vector of elements, usually real numbers. 15:27.660 --> 15:34.580 And then every cell, every node has a neighborhood, definitely 15:34.580 --> 15:41.880 depending on the current or depending on the structure of that that 15:41.880 --> 15:43.420 mesh that you have there. 15:44.840 --> 15:50.800 So as obviously shown here, so you can have a mesh-connected array or 15:50.800 --> 15:54.580 you have a hexagonal grid, then you have different neighborhoods, and 15:54.580 --> 15:57.960 then you can look at neighborhoods of distance one, two, three, 15:58.080 --> 16:00.040 whatever you like to have there. 16:01.100 --> 16:04.140 And now the question is how we use that. 16:04.620 --> 16:09.940 So we would like to, like some input data we have, and the input data 16:09.940 --> 16:17.540 are vectors of the same size, like also vectors out of Rn, and they 16:17.540 --> 16:20.320 have to be mapped on this network. 16:20.600 --> 16:25.280 And an input sample is described by some real vector, as I said. 16:26.360 --> 16:30.720 So t is the index of the sample, you could say the time or the index 16:30.720 --> 16:37.700 of that number of data that you have there, entering the system at the 16:37.700 --> 16:39.160 discrete time coordinate t. 16:39.240 --> 16:42.220 So we just say it's at time t, we have a certain input. 16:43.500 --> 16:51.500 And now every node, as I said, has a certain vector, a weight vector, 16:52.200 --> 16:55.020 which has the same number of elements as the input sample. 16:55.580 --> 17:01.740 And now you would like to organize your 17:06.300 --> 17:11.640 network such that it corresponds adequately to that vector. 17:11.840 --> 17:13.160 So what is the idea? 17:13.680 --> 17:15.360 You would like to do color mapping. 17:15.520 --> 17:22.000 So you have a problem with certain input vectors in three dimensions. 17:22.460 --> 17:27.200 Here, if you look at colors, you have three dimensions, three values 17:27.200 --> 17:28.680 for red, green, and blue. 17:29.560 --> 17:36.840 And if, for example, you have the color light blue, this would be 0, 17:36.920 --> 17:39.200 100, 255, so that would be the color. 17:39.920 --> 17:46.740 And in this arrangement of this hexagonal array of nodes here, this 17:46.740 --> 17:50.000 node, for example, would have exactly that weight vector. 17:51.420 --> 17:56.120 And now we would like to organize that map, this self-organizing map, 17:56.180 --> 18:02.420 such that neighboring nodes are in some way similar to the node that 18:02.420 --> 18:03.340 has this value. 18:04.120 --> 18:07.000 Now you see in this current setting, they are very different. 18:07.240 --> 18:11.280 The neighboring nodes are not really similar to what we see there. 18:12.280 --> 18:17.860 And so that, for example, is definitely not in the neighborhood, like 18:17.860 --> 18:23.120 this lilac is not in the neighborhood of light blue. 18:23.540 --> 18:25.580 Should be a different value there. 18:26.200 --> 18:32.960 And so they should be clustered such that something similar to this 18:32.960 --> 18:34.180 should appear in the end. 18:35.240 --> 18:37.300 And how could it learn that? 18:38.080 --> 18:43.400 In the beginning, we assign some random values, which you can see in 18:43.400 --> 18:47.280 this sample map here. 18:48.220 --> 18:51.060 And then we have to look at how to modify that. 18:51.440 --> 18:53.320 And we modify it in the following way. 18:54.340 --> 19:01.980 We map it to a location, like we have a certain input, and now we map 19:01.980 --> 19:05.920 it to a location which matches best with that input vector. 19:08.000 --> 19:13.380 And so some distance, for example, Euclidean distance, you can have, 19:13.640 --> 19:17.760 depending on the problem, you have different distance metrics. 19:19.040 --> 19:25.000 And so now the following happens. 19:25.240 --> 19:29.200 We compare it, as I said, we compare it, the best matching node on the 19:29.200 --> 19:37.620 map is selected, and then the neighboring nodes are, or the weights in 19:37.620 --> 19:46.240 the neighboring neurons, or these vectors, are drawn closer to the 19:46.240 --> 19:47.440 current input. 19:48.900 --> 19:54.820 And so the node that is here is what we call the winner for that 19:54.820 --> 19:55.240 input. 19:55.660 --> 20:00.000 It's the one which is closest to our input. 20:01.200 --> 20:06.660 And now we change the weight vectors towards the input vector, 20:07.540 --> 20:12.280 according to some equation, which I'll show you on the next slide. 20:12.400 --> 20:17.440 But you see already, this example of the self-organizing map already 20:17.440 --> 20:21.160 has some completely different structure from what we saw before. 20:21.660 --> 20:28.040 Here, neighboring nodes already have similar weight settings. 20:28.740 --> 20:35.760 So this looks more like something where the colors are, or the weights 20:35.760 --> 20:41.160 are, or neighboring neurons have weights which are similar. 20:41.420 --> 20:47.820 The differences of the weights in neighboring nodes is minimized. 20:49.160 --> 20:52.780 So what is the equation, an obvious equation? 20:53.560 --> 21:01.340 We have to determine the input, or no, the weight vector for the next 21:01.340 --> 21:03.460 time instance. 21:04.060 --> 21:08.540 And what we do there is that we have two different cases. 21:09.080 --> 21:14.200 We have certain indexes, indices like neurons, which are in the 21:14.200 --> 21:16.760 neighborhood and see the neighborhood of the winner. 21:17.760 --> 21:19.620 And only those are changed. 21:19.680 --> 21:21.060 The other ones are the same. 21:21.540 --> 21:24.640 T is certainly the discrete time index of the variables. 21:25.420 --> 21:31.400 And now this alpha t is indicating how fast we are actually learning, 21:31.580 --> 21:34.880 how fast we are modifying the weights. 21:35.500 --> 21:40.160 And this is not a constant value, which is the same throughout the 21:40.160 --> 21:45.220 learning process, but you could say it is adaptive, or it could be 21:45.220 --> 21:48.360 done in an adaptive way, that it starts with large values and 21:48.360 --> 21:49.480 decreases over time. 21:49.920 --> 21:53.780 But this only makes sense if you have, again, a stable environment. 21:53.920 --> 21:57.320 If you have an environment which will change, then it would not be 21:57.320 --> 22:05.660 good to have a decreasing learning rate, because then, or at least, 22:05.840 --> 22:10.660 you would need some indication that something has changed, and then 22:10.660 --> 22:15.260 you would have to increase this learning step again. 22:16.880 --> 22:24.460 Okay, so this is just how you would adjust the values in those 22:24.460 --> 22:30.660 neurons, and then you would have a distribution of those values in 22:30.660 --> 22:32.800 that self-organizing map. 22:33.100 --> 22:38.900 And if you now get some weight vector, which is not exactly in one of 22:38.900 --> 22:42.840 those nodes, you always have one node which is close to, or the 22:42.840 --> 22:46.480 closest to, what you actually had learned in that map. 22:46.500 --> 22:47.020 You have a question. 22:54.040 --> 22:58.620 We would like to find, like as I said, we would like to find the 22:58.620 --> 23:01.880 neuron which is the closest to the current input. 23:03.300 --> 23:07.120 We go to that node, we identify the winner, the one which has the 23:07.120 --> 23:21.500 closest distance, because that's the node which is the closest to the 23:21.500 --> 23:31.740 current input, and then we would like to have the situation that the 23:31.740 --> 23:37.140 neighboring nodes are, like if we look at neighboring nodes, their 23:37.140 --> 23:44.900 distance to this node here, like all the nodes, the neurons in the 23:44.900 --> 23:50.980 neighborhood of distance one, like just the structural distance one, 23:51.720 --> 23:57.680 the weight vectors in that neighborhood should have a Euclidean 23:57.680 --> 24:01.320 distance with respect to their weight vectors, which is smaller than 24:01.320 --> 24:06.800 the distances of the neurons which are around that, which are further 24:06.800 --> 24:07.200 away. 24:07.960 --> 24:11.560 So we would like to make sure that neighboring nodes have in some way 24:11.560 --> 24:14.140 neighboring weight vectors. 24:14.880 --> 24:21.100 And then these can be used for further functionality. 24:21.860 --> 24:25.960 So it's not just finding out a certain node, but then you could do 24:25.960 --> 24:28.560 something depending on what you have in that node. 24:29.320 --> 24:38.980 So that is the way this is essentially working, so 24:42.840 --> 24:48.060 you have to, certainly you will get new inputs, and then if something 24:48.060 --> 24:52.400 changes in your system, you will modify the self-organizing map. 24:53.820 --> 25:00.160 So here it shows that that was the starting setting, the random 25:00.160 --> 25:06.940 setting of that self-organizing map for this color system. 25:07.600 --> 25:12.860 And then if you present certain inputs, some color values, in this 25:12.860 --> 25:16.580 example, just gradually is modified. 25:17.300 --> 25:25.640 And you see that it is actually changing all the time, depending on in 25:25.640 --> 25:29.240 which area you actually, or with which type of inputs you actually 25:29.240 --> 25:29.540 have. 25:31.200 --> 25:42.320 So this can adjust later on, and for this you don't need any 25:42.320 --> 25:46.720 supervision, this is just unsupervised learning. 25:46.860 --> 25:52.100 You have this network and it just adjusts to the current input 25:52.100 --> 25:52.860 vectors. 25:55.300 --> 26:05.720 So you can do that with the decreasing learning rate, that's what is 26:05.720 --> 26:06.620 indicated here. 26:07.180 --> 26:10.400 The radius gets smaller, the local corrections in the map will be more 26:10.400 --> 26:16.700 specific, and then you have this kind of development. 26:17.980 --> 26:21.460 Okay, now the next part would be swarm intelligence. 26:22.800 --> 26:29.700 Now I have told you certain things about swarm intelligence already, I 26:29.700 --> 26:33.460 have shown you something on ant algorithms, there are many different 26:33.460 --> 26:37.880 approaches to swarm intelligence, and one could say that swarm 26:37.880 --> 26:41.740 intelligence is an interesting part, very much related to organic 26:41.740 --> 26:42.240 computing. 26:44.000 --> 26:51.360 But I decided to skip this part on ant algorithms, I have shown you 26:51.360 --> 26:54.520 already a little bit about that, like I've shown you these slides 26:54.520 --> 26:59.540 already, I will skip this part in this course this time. 27:00.500 --> 27:05.980 So this will not be covered, and in particular particle swarm 27:05.980 --> 27:07.280 optimization will not be covered. 27:07.420 --> 27:10.800 I've shown you optimization methods that we actually use in the 27:10.800 --> 27:16.800 application areas for organic computing, we mainly use evolutionary 27:16.800 --> 27:20.920 algorithms there, we use learning classifier systems for the online 27:20.920 --> 27:26.520 learning step, and so I decided I will skip that because I wanted to 27:26.520 --> 27:32.380 tell you a little bit more about robustness, trust, and so on. 27:32.640 --> 27:37.640 And we only have three more lectures, and so then we also have a 27:37.640 --> 27:42.040 little bit more time for showing you in more depth the application 27:42.040 --> 27:44.180 areas of organic computing in the end. 27:45.000 --> 27:53.900 So this is skipped, and we can briefly go through all that. 27:54.320 --> 27:59.840 So this is nicely animated, you can look at all the different things 27:59.840 --> 28:04.840 about ant colony optimization and learn something about that. 28:04.980 --> 28:11.840 So it's all in there, but yeah, maybe just this comparison with 28:11.840 --> 28:13.820 genetic algorithms. 28:14.420 --> 28:19.960 In genetic algorithms what we have is that we have individual 28:19.960 --> 28:26.420 solutions, individual genotypes, which are evaluated and maybe 28:26.420 --> 28:29.200 inherited into the next generation. 28:30.540 --> 28:40.420 So we have solutions that get more and more refined or are worked on. 28:40.680 --> 28:45.680 We have the operations like crossover and mutation, so we work 28:45.680 --> 28:47.080 directly on the solutions. 28:48.060 --> 28:55.780 Whereas in ant colony optimization, we look for getting experience on 28:55.780 --> 28:57.000 how to solve a problem. 28:57.720 --> 29:02.160 So you could say we have some kind of parameter-based heuristic, how 29:02.160 --> 29:04.880 we can actually define or design a solution. 29:05.720 --> 29:10.280 And this heuristic is our pheromone matrix that we have on the 29:10.280 --> 29:13.900 different paths or different decision points in our algorithm. 29:14.960 --> 29:20.620 And so there you learn based on accumulated experience, whereas in 29:20.620 --> 29:25.060 genetic algorithms you learn and have explicit solutions available. 29:25.860 --> 29:30.800 And in ant colony optimization you only get some body or some 29:30.800 --> 29:33.380 knowledge how to design a solution. 29:34.240 --> 29:40.840 So these two ways are different, these approaches to optimization, and 29:42.140 --> 29:48.120 this shows that they actually have different areas where they are very 29:48.120 --> 29:50.080 adequate. 29:51.400 --> 29:58.600 So ant colony optimization is a very powerful approach if you have, 29:58.700 --> 30:04.060 for example, permutation problems that usually perform quite well. 30:05.580 --> 30:11.100 But I didn't want to go into that in detail. 30:11.900 --> 30:16.040 So we have looked at several machine learning methods in this chapter. 30:16.280 --> 30:18.660 I definitely showed you something on learning classifiers. 30:20.080 --> 30:26.000 And here we not only looked at genetic algorithms, but also at rule 30:26.000 --> 30:26.560 combining. 30:29.520 --> 30:32.660 Should have added this here, so I do it by handwriting. 30:33.560 --> 30:42.120 So rule combining is an important way of improving the accuracy and 30:42.120 --> 30:44.620 the efficiency of learning classifier systems. 30:45.260 --> 30:48.080 I very briefly showed you something about neural networks. 30:48.660 --> 30:53.060 I did not tell you more details about ant colony optimization. 30:53.660 --> 30:56.760 I indicated that a few times, how it is actually working using 30:56.760 --> 30:57.880 pheromone structures. 30:59.600 --> 31:05.440 And certainly if we look at the requirements of organic computing, in 31:05.440 --> 31:10.540 organic computing the central point is that we assume we will have a 31:10.540 --> 31:11.980 dynamically changing environment. 31:12.660 --> 31:14.900 And so we need adaptive systems. 31:15.480 --> 31:19.880 Learning classifier systems have the advantage of being adaptive, and 31:19.880 --> 31:27.440 so neural networks learn or can be trained, but don't learn 31:27.440 --> 31:28.100 afterwards. 31:28.620 --> 31:32.860 And so learning classifier systems are quite adequate. 31:34.080 --> 31:37.740 And in the next chapter, we will look at trustworthiness and 31:37.740 --> 31:42.520 robustness issues, which are very important for organic computing. 31:42.700 --> 31:48.040 Because if you have an autonomously learning and modifying system, how 31:48.040 --> 31:54.860 can you get any expectation or trustworthy expectation on how they 31:54.860 --> 31:58.720 will actually perform the functionality that you would like them to 31:58.720 --> 31:58.880 do. 32:00.580 --> 32:06.500 And so that's the final part, last part on this chapter. 32:07.120 --> 32:13.400 And we go to the next chapter on robustness and flexibility, which I 32:13.400 --> 32:15.460 uploaded last night. 32:17.100 --> 32:25.780 So this is now on a topic that essentially I mentioned already in the 32:25.780 --> 32:26.080 beginning. 32:27.060 --> 32:32.180 I emphasized always that robustness, flexibility, trustworthiness are 32:32.180 --> 32:34.580 essential properties of organic computing systems. 32:34.580 --> 32:40.600 And one remark that I would like to also include here is that you have 32:40.600 --> 32:42.320 to register for the final exam. 32:45.020 --> 32:51.420 You know that registration is open and it ends on July 6th. 32:51.640 --> 32:56.580 So if you would like to take the exam at the end of this semester, 32:57.640 --> 32:58.700 please register. 33:00.580 --> 33:03.420 So back to the problem that we looked at. 33:03.540 --> 33:07.940 You have seen this or a similar slide quite early in the course. 33:08.860 --> 33:13.460 So we look at the increasing presence of information and communication 33:13.460 --> 33:14.260 systems. 33:15.380 --> 33:19.840 And in particular, we have safety and mission critical applications. 33:20.600 --> 33:28.020 And for that, we certainly need to be able to talk about robustness, 33:28.020 --> 33:31.140 adaptivity, flexibility, trustworthiness of those systems. 33:31.480 --> 33:36.000 How do those systems actually respond to changes in their environment, 33:36.120 --> 33:39.600 to disturbances, to unexpected situations? 33:40.400 --> 33:46.540 Can we use them in a stable way, even if their operational environment 33:46.540 --> 33:49.100 is changing quite a bit? 33:49.220 --> 33:54.600 Or can we modify our expectations, can we modify the functionality and 33:54.600 --> 34:03.460 still get an adaptation of the system to perform with respect to the 34:03.460 --> 34:05.240 new evaluation criteria? 34:06.240 --> 34:07.320 So that would be flexibility. 34:07.680 --> 34:12.600 And we will go into those details and look at how we can model that, 34:12.600 --> 34:18.540 how we can talk about the ability to adapt to given requirements. 34:19.280 --> 34:24.220 We have looked at that in an early part in this course. 34:25.340 --> 34:27.360 So we have a system model. 34:27.980 --> 34:29.920 We have our system and observation and control. 34:30.260 --> 34:31.920 We have certain input, we have certain output. 34:32.700 --> 34:35.980 This is our system with inputs and outputs. 34:36.360 --> 34:38.200 We have looked at that quite often. 34:38.380 --> 34:42.980 You have worked on that in the examples with the easy agent simulation 34:42.980 --> 34:43.760 system. 34:44.640 --> 34:48.200 And the question is, if we have such a system, which is working in 34:48.200 --> 34:53.440 some environment, how can we describe what its current state or 34:53.440 --> 34:54.400 configuration is? 34:55.000 --> 35:00.460 So if we talk about some kind of state, there are many things that we 35:00.460 --> 35:01.120 have to look at. 35:01.720 --> 35:05.740 There will be the structure, nodes and edges, the attributes, certain 35:05.740 --> 35:07.720 things will be static, which don't change. 35:08.380 --> 35:11.080 Input, output will be dynamic, will change. 35:11.180 --> 35:12.980 Environmental parameters might change. 35:13.080 --> 35:15.580 So certain things have to be described. 35:15.780 --> 35:20.240 And to describe the state, we need a very large number of values. 35:21.200 --> 35:25.480 And this then leads to some kind of state space for that system. 35:26.280 --> 35:31.140 That's all the different values of the variables, the attributes that 35:31.140 --> 35:33.960 are needed to describe what this system is doing. 35:35.380 --> 35:38.820 Now, we want to argue about that system. 35:39.560 --> 35:45.400 And so we need some external observer, some user or whatever, having 35:45.400 --> 35:48.020 access to almost all the parameters. 35:48.340 --> 35:49.620 We have looked at that before. 35:49.920 --> 35:53.020 We talked about, like when we talked about self-organization and 35:53.020 --> 35:58.580 degree of self-organization, we talked about the configuration space, 35:58.700 --> 36:01.860 external configuration space, internal configuration space, and so on. 36:01.900 --> 36:02.900 So we know all these things. 36:03.680 --> 36:10.260 So there is some external entity, the user, having access to most of 36:10.260 --> 36:10.840 the parameters. 36:12.140 --> 36:18.300 And this user actually provides the evaluation criteria, determines 36:18.300 --> 36:22.520 what this system should do, and evaluates how well it is performing. 36:23.200 --> 36:27.860 Now, so we have certain objectives, certain goals. 36:29.080 --> 36:33.640 And for example, we would like to have a traffic light system where 36:33.640 --> 36:40.300 the objective would be to reduce the waiting time or the number of 36:40.300 --> 36:40.620 stops. 36:41.340 --> 36:45.800 And then we would evaluate a system by looking at a certain street 36:45.800 --> 36:49.620 network and look at how much, how many stops actually are there 36:49.620 --> 36:54.460 because of the settings of those traffic lights. 36:55.180 --> 36:58.860 So we have certain evaluation criteria, and it means that we map 36:58.860 --> 37:00.180 our... 37:00.180 --> 37:01.120 oops, what is this? 37:02.180 --> 37:04.600 Okay, I wanted to draw that. 37:05.060 --> 37:09.940 So there will be some evaluation criteria, some criteria which are 37:09.940 --> 37:15.460 called ETA for evaluation criteria, ETA mapping the state space into, 37:15.920 --> 37:19.020 well, some RK here. 37:19.180 --> 37:24.620 Assume we have here, let's say, ETA1, ETA2. 37:25.060 --> 37:29.780 And I assume that in these evaluation criteria, we in some way 37:29.780 --> 37:36.320 indicate how far we are deviating from the current objectives. 37:37.700 --> 37:42.880 So the best thing would be to be very, like to optimize, to minimize 37:42.880 --> 37:44.340 the values that we have there. 37:44.660 --> 37:52.020 We will have certain values for our system, like depending on the 37:52.020 --> 37:56.620 current state of the system, we will get certain values for those two 37:56.620 --> 37:57.340 criteria. 37:58.020 --> 38:02.280 And certainly we are interested in somehow those Pareto optimal 38:02.280 --> 38:08.060 values, which are the closest to the origin. 38:10.020 --> 38:14.840 And now we would like to evaluate that system. 38:15.280 --> 38:21.920 So this user may certainly or may be able to modify certain parameter 38:21.920 --> 38:22.500 values. 38:22.560 --> 38:24.100 You know all about that already. 38:25.040 --> 38:29.580 And I will show you one example of such a system, traffic light or 38:29.580 --> 38:34.780 traffic, this organic traffic control project that we worked on there. 38:34.960 --> 38:39.460 We had a certain environment, some street network, so individual 38:39.460 --> 38:45.040 intersections, every intersection, we have certain parameters that we 38:45.040 --> 38:45.740 have to look at. 38:45.820 --> 38:47.380 So you see quite a complex network. 38:47.480 --> 38:50.520 That's a real street network at the city of Hamburg. 38:52.380 --> 38:54.600 And what do we look at there? 38:54.880 --> 39:01.640 So we have a certain traffic light and for that we have, like that's 39:01.640 --> 39:06.980 our layer zero, we have detectors looking at how many cars are driving 39:06.980 --> 39:13.420 in that or coming into or on that street, how many cars actually would 39:13.420 --> 39:20.180 like to turn that way, how many cars are like moving on the different 39:20.180 --> 39:22.340 turns of that intersection. 39:22.500 --> 39:29.240 We'll go again into that example at the end of our course when I tell 39:29.240 --> 39:30.020 about applications. 39:30.200 --> 39:34.740 But I wanted to indicate what kind of information actually we might 39:34.740 --> 39:37.480 need if we talk about the state of a system. 39:38.980 --> 39:45.440 So at one particular traffic light, how would we control the traffic 39:45.440 --> 39:45.680 light? 39:45.740 --> 39:47.440 There are many different ways of doing that. 39:47.440 --> 39:52.160 So there are certain fixed time or fixed settings for the traffic 39:52.160 --> 39:54.900 light, but there are also dynamic ways of doing that. 39:55.020 --> 40:00.200 So you might have several parameters which are determining the length 40:00.200 --> 40:01.060 of the green phase. 40:01.160 --> 40:06.400 So this would be the length of the green phase of one particular 40:06.400 --> 40:14.380 direction on that particular intersection, which initially would look 40:14.380 --> 40:18.960 at a variable which tells whether there are cars waiting. 40:19.140 --> 40:22.940 If there is no car waiting, that's it, you don't need a green phase. 40:23.440 --> 40:24.800 You can skip that green phase. 40:25.600 --> 40:31.320 If there's a car waiting, you have a minimum green interval, the 40:31.320 --> 40:36.000 minimum time you need for a car to actually move over that 40:36.000 --> 40:37.280 intersection. 40:38.580 --> 40:44.880 Then you have certain extensions depending on how many cars are 40:44.880 --> 40:45.740 waiting in line. 40:46.560 --> 40:49.540 If you have more cars waiting there, you need more time to let them 40:49.540 --> 40:51.060 all drive through. 40:51.680 --> 40:58.080 And then you have some initial green phase that is ending there. 40:58.140 --> 41:01.660 You have a certain maximum number of actuations that you look at. 41:02.300 --> 41:07.280 But if you have very dense traffic, you would even extend that 41:07.280 --> 41:07.720 slightly. 41:08.200 --> 41:16.740 So the dense traffic means that your gap in between successive cars is 41:16.740 --> 41:17.400 very small. 41:17.700 --> 41:18.800 That's dense traffic. 41:19.600 --> 41:23.280 For that, it is an indicator that there's a lot of traffic in this 41:23.280 --> 41:25.280 direction and you should extend it again. 41:25.780 --> 41:26.960 Then you have maximum green. 41:27.680 --> 41:32.600 So what kind of parameters would you have here indicating whether cars 41:32.600 --> 41:33.520 are waiting at all? 41:33.720 --> 41:37.340 You have the minimum green time, you have a certain extension 41:37.340 --> 41:43.920 interval, you need that value, you need the maximum initial green 41:43.920 --> 41:48.240 value, you have to talk about the allowable gap, and you need the 41:48.240 --> 41:49.320 maximum green value. 41:50.000 --> 41:54.640 So a range of parameters that could be built into such a traffic light 41:54.640 --> 41:57.780 and that would be a dynamic way of controlling such a traffic light. 41:59.040 --> 42:03.680 Okay, I just wanted to indicate parameters that you need in order to 42:03.680 --> 42:06.720 describe what the current state of a system actually is. 42:07.400 --> 42:11.660 And then certainly you also have your control architecture on top of 42:11.660 --> 42:12.040 that. 42:12.580 --> 42:17.380 You have your next layer here, the next layer there, and then you have 42:17.380 --> 42:19.480 the user setting the objectives. 42:19.600 --> 42:20.060 You have a question? 42:33.210 --> 42:42.310 This here is just for a certain number of cars, you have a certain 42:42.310 --> 42:43.290 extension. 42:44.170 --> 43:01.210 So seconds per actuation means that while it is green, this is your 43:01.210 --> 43:06.910 street, here is your intersection, there you have a sensor. 43:08.230 --> 43:11.190 And now cars are moving over that sensor. 43:12.270 --> 43:15.610 And for every actuation, that means for every detection of a car that 43:15.610 --> 43:19.670 is moving across that, that's an actuation and you get an extension. 43:20.970 --> 43:26.210 Now, what you can also measure is the time between successive 43:26.210 --> 43:27.790 actuations, which is the gap. 43:29.090 --> 43:31.590 And so this can extend it. 43:32.110 --> 43:35.650 How this is done is up to how you want to design that. 43:36.330 --> 43:41.370 So there are actually systems around for traffic engineering where you 43:41.370 --> 43:47.430 can control exactly all those parameters and also set the amount of 43:47.430 --> 43:50.530 time that you would give as an additional extension if there is very 43:50.530 --> 43:51.190 dense traffic. 44:04.960 --> 44:10.900 So the first is just looking at how many actuations do you have, and 44:10.900 --> 44:15.720 then you look at how long it takes, like what the gap is between 44:15.720 --> 44:16.820 successive actuations. 44:17.360 --> 44:21.380 And if it's still very, very small, then you add a little bit more and 44:21.380 --> 44:22.180 then that's it. 44:23.380 --> 44:26.800 So it just shows that you can have something which is quite complex 44:26.800 --> 44:28.120 setting of parameters. 44:29.240 --> 44:33.560 And in our applications, actually, we did not use this model, but we 44:33.560 --> 44:37.380 used a simple model where we had fixed time control, and we just 44:37.380 --> 44:42.000 modified those fixed times depending on the current traffic flow. 44:42.160 --> 44:46.280 So this was in some way a different approach to traffic light 44:46.280 --> 44:50.760 settings, but I just wanted to indicate what kind of extra information 44:50.760 --> 44:51.500 you might need. 44:51.700 --> 44:54.260 So this is summarized again here. 44:54.700 --> 44:57.760 If you have the street network data, what you need, that's the 44:57.760 --> 44:59.360 structure of your street network. 45:00.160 --> 45:04.120 You need the detector information, the number of cars that you have 45:04.120 --> 45:10.200 seen there, the arrival times, the speed of the cars, the gaps, and 45:10.200 --> 45:11.140 things like that. 45:12.340 --> 45:15.380 It certainly also depends on how many detectors you have. 45:15.480 --> 45:18.640 You might have not just one detector, but more detectors. 45:19.200 --> 45:22.080 And so this is all the information. 45:22.220 --> 45:25.180 Traffic light controller settings certainly have to be in there. 45:25.180 --> 45:31.120 The rule base, the layer one data, what kind of rules do you have 45:31.120 --> 45:38.700 currently, what kind of simulator do you have in your offline learning 45:38.700 --> 45:43.820 system in the second layer, and what are actually your objectives 45:43.820 --> 45:45.000 given by the user. 45:46.600 --> 45:52.640 Objectives could be reduce number of stops, reduce energy consumption, 45:53.140 --> 45:54.240 or things like that. 45:55.180 --> 45:59.720 Just to indicate, if you actually look at a state space, it's not 45:59.720 --> 46:03.440 something where you have a handful of parameters, can be quite a large 46:03.440 --> 46:03.880 system. 46:04.500 --> 46:09.420 And then certainly the question is actually what are the essential 46:09.420 --> 46:14.060 parameters that you have to look at in order to behave adequately in 46:14.060 --> 46:14.780 such an environment. 46:16.700 --> 46:21.720 Okay, again, this example, you have a certain state space. 46:22.720 --> 46:28.580 And then so in your state space, you have certain points where you 46:28.580 --> 46:31.580 actually can be at different situations. 46:32.460 --> 46:39.420 And for every situation, you look at the quality with respect to your 46:39.420 --> 46:40.240 objectives. 46:40.640 --> 46:44.540 If objectives are number of stops and the delay that you have, you get 46:44.540 --> 46:47.580 entries in that two-dimensional objective space. 46:48.420 --> 46:53.520 And certainly you would like to be somewhere at that Pareto optimum 46:53.520 --> 46:57.500 front, where you can reduce the number of stops and the delay at the 46:57.500 --> 46:58.000 same time. 47:01.640 --> 47:08.360 And certainly you have certain neighborhoods here in the state space. 47:08.460 --> 47:12.660 And it's not necessarily the case that if you have a situation like 47:12.660 --> 47:18.600 here, or a state very close to the one, that you get to the same value 47:18.600 --> 47:20.500 or to a value that is close to that. 47:20.980 --> 47:25.760 But maybe that state that is very different may also lead to that 47:25.760 --> 47:26.400 value. 47:26.840 --> 47:32.320 And so neighborhoods in the state space are not necessarily 47:32.320 --> 47:38.640 neighborhoods here, but can move to very different situations in your 47:38.640 --> 47:39.480 objective space. 47:39.560 --> 47:42.880 And this is the problem that what you would like to have is something 47:42.880 --> 47:47.260 which is smooth, that if you have just small changes in the state 47:47.260 --> 47:50.320 space, you only get small changes in your objective space. 47:50.700 --> 47:56.100 But this certainly very much depends on the way you actually have set 47:56.100 --> 48:03.420 your parameters, how you represented your system, and what kind of 48:03.420 --> 48:07.300 objectives you have, how the fitness landscape actually looks like. 48:09.100 --> 48:13.820 So this is what you have to look at, all kinds of different mappings 48:13.820 --> 48:16.900 in state space, or from state space to objective space. 48:17.700 --> 48:21.860 Essentially, you could say this is, if we go back to what we saw 48:21.860 --> 48:27.960 before, this would be all the genotypes, and then we have the 48:27.960 --> 48:32.260 evaluation of the phenotypes, which lead to the objective space. 48:33.840 --> 48:40.260 And now, what I would like to do is I would like to classify the state 48:40.260 --> 48:41.320 space in some way. 48:42.180 --> 48:46.840 To classify that, I just draw a simple mapping or a simple 48:46.840 --> 48:48.060 visualization of that. 48:48.220 --> 48:53.880 So here, on top there, we have this simple view of the system and its 48:53.880 --> 48:54.340 environment. 48:55.180 --> 48:58.360 And this results in some kind of global state space. 48:59.400 --> 49:03.520 And then there's a certain subset of elements, which here is indicated 49:03.520 --> 49:07.340 as being some simple subset in this way. 49:07.960 --> 49:12.880 It not necessarily is such a connected area, maybe some subset of 49:12.880 --> 49:13.260 elements. 49:14.160 --> 49:20.600 So if you have some metric on the distance in the state space, it is 49:20.600 --> 49:24.700 not necessarily the case that they are that close together, that 49:24.700 --> 49:30.180 neighboring nodes in the state space all are in the target space. 49:30.260 --> 49:31.880 But I just visualize it in this way. 49:32.460 --> 49:37.680 So this target space is in some way the zero space of our evaluation 49:37.680 --> 49:38.280 criteria. 49:38.920 --> 49:45.480 So I said we have all our evaluation criteria, and now I say we are in 49:45.480 --> 49:47.380 the zero space. 49:47.560 --> 49:51.740 That means we have no deviations from our objectives. 49:51.740 --> 49:58.300 They are all satisfied, or at least very close to those objectives. 49:58.440 --> 50:00.060 There will be some thresholds. 50:00.140 --> 50:02.040 Then we say this is the zero space. 50:02.140 --> 50:02.760 We are satisfied. 50:04.500 --> 50:06.760 And then there's something around that. 50:07.440 --> 50:11.140 So we might have certain thresholds here for the initial thing. 50:11.860 --> 50:17.260 And then we might have some tolerance with respect to the deviation 50:17.260 --> 50:22.300 from objectives, that we say, okay, our system should be running, 50:22.740 --> 50:26.460 should be functional, but maybe it's not efficient. 50:27.920 --> 50:31.260 So it should be effective, it should perform its functionality, but we 50:31.260 --> 50:34.980 also have the requirement that it should be very efficient, produce 50:34.980 --> 50:38.120 little cost, and so on. 50:38.140 --> 50:42.300 Or if you have a car, you say you would like to be able to drive the 50:42.300 --> 50:47.800 car at any speed, or at a certain range of speeds, and now if 50:47.800 --> 50:51.560 something goes wrong, you might still have an acceptable behavior. 50:51.940 --> 50:55.020 Maybe you run at a lower speed, but it's still acceptable. 50:55.440 --> 50:58.480 But you would like to be in the target space, but it's still 50:58.480 --> 50:58.940 acceptable. 51:00.220 --> 51:05.560 So that would be the acceptance space, which is certainly containing 51:05.560 --> 51:06.500 the target space. 51:07.160 --> 51:15.000 And that needs some thresholds which lead to those which classify the 51:15.000 --> 51:17.540 states that are still acceptable. 51:18.600 --> 51:25.480 And then there is a space around that, a so-called survival space, you 51:25.480 --> 51:30.200 are not satisfied anymore with what the system is doing, you are 51:30.200 --> 51:33.360 running your car, driving your car, and you have a flat tire. 51:34.020 --> 51:39.260 Now you cannot drive on, you have to stop, but if you have a flat 51:39.260 --> 51:46.680 tire, and if you have a repair set or a spare tire available, if you 51:46.680 --> 51:53.500 have a spare tire, you can replace the flat tire, and then you can 51:53.500 --> 51:54.080 drive on. 51:55.380 --> 51:59.400 Certainly at a reduced speed, but you still can drive on. 51:59.500 --> 52:01.600 So this is what we call the survival space. 52:02.280 --> 52:08.420 You can perform certain actions on your system, you have certain 52:08.420 --> 52:13.900 control actions, and you can redirect it in order to, like if you have 52:13.900 --> 52:20.400 been there or there, and now somehow you got into this area, then 52:20.400 --> 52:23.640 there is a number of control actions which actually would lead you 52:23.640 --> 52:25.160 back into the acceptance space. 52:27.100 --> 52:31.320 And so we say that's the survival space, and around that, that's a 52:31.320 --> 52:34.340 system which is completely broken, you cannot do anything with that 52:34.340 --> 52:36.900 anymore, it's gone. 52:37.340 --> 52:38.780 So we call that the dead zone. 52:40.920 --> 52:45.240 So this is some kind of classification, and you can imagine that this 52:45.240 --> 52:52.260 certainly will have to do with the way we would like to characterize 52:52.260 --> 52:56.700 the robustness and the flexibility of a system. 52:57.800 --> 53:02.180 So we might have certain changes in our system, changes in the state 53:02.180 --> 53:08.740 space, and we would require that this does not lead actually to large 53:08.740 --> 53:10.600 changes in the objective space. 53:12.340 --> 53:15.620 And that's what we would like to talk about here. 53:16.480 --> 53:20.820 And if we would like to talk about robustness, we have to talk about 53:20.820 --> 53:25.400 changes that are there, which are modifying the behavior of the 53:25.400 --> 53:27.620 system, so we talk about disturbances. 53:28.740 --> 53:36.320 Some modifications which are changing the current state by some 53:36.320 --> 53:41.660 external influence, something is broken, or maybe the user would like 53:41.660 --> 53:42.800 to get a new function. 53:43.760 --> 53:47.580 Then something has changed, and the system has to adjust to that. 53:49.020 --> 53:55.180 So the question is how those disturbances modify the classification of 53:55.180 --> 53:59.340 the states that we just have made from target space to acceptance 53:59.340 --> 54:02.160 space, survival space, and dead space. 54:04.460 --> 54:05.160 Or dead zone. 54:06.140 --> 54:08.360 So the first thing we look at is robustness. 54:09.000 --> 54:12.340 And there are many different notions of robustness available in the 54:12.340 --> 54:16.940 literature, depending on what kind of access you have to the different 54:16.940 --> 54:18.680 parameters of the system. 54:19.800 --> 54:25.200 And so an important point is that we can only talk about robustness if 54:25.200 --> 54:27.560 we have some notion of disturbances. 54:28.620 --> 54:34.320 You can only say that this system is robust with respect to certain 54:34.320 --> 54:36.700 changes in the state space. 54:37.640 --> 54:42.300 Those can be tolerated in some way. 54:42.900 --> 54:48.420 And we say that a system is strongly robust with respect to these 54:48.420 --> 54:56.440 disturbances if any disturbance there maps the target space or the 54:56.440 --> 54:58.160 acceptance space into itself. 54:58.160 --> 54:59.180 What does that mean? 54:59.600 --> 55:04.280 If we are at this point and we have a disturbance, this will be mapped 55:04.280 --> 55:07.880 to another point in the target space, if it's strongly robust. 55:08.760 --> 55:15.320 Or if we are here in the acceptance space, we will still remain in the 55:15.320 --> 55:20.420 acceptance space, or be moved to some other state, but it's still in 55:20.420 --> 55:24.760 the acceptance space with respect to those disturbances that we 55:24.760 --> 55:25.180 consider. 55:26.280 --> 55:31.780 So, we need some notion about what kind of disturbances are looked at, 55:32.420 --> 55:39.780 and then we can see how our acceptable states will perform if we have 55:39.780 --> 55:41.780 those disturbances. 55:43.220 --> 55:49.000 And now the next level would be that we say it is weakly robust if the 55:49.000 --> 55:52.080 acceptance space is always mapped into the acceptance space. 55:52.080 --> 55:56.660 That means, this is the same here, but it may be that we are in there, 55:56.700 --> 56:00.500 in the target space, and we have a disturbance, and it moves us out of 56:00.500 --> 56:06.720 the target space, the performance is not as good as it was before, but 56:06.720 --> 56:09.580 we are still in the acceptance space. 56:11.020 --> 56:15.580 So, weakly robust means that after such a disturbance, we might no 56:15.580 --> 56:19.680 longer be completely satisfied, but we still accept the performance 56:19.680 --> 56:23.540 and hope that it will improve again to go into the target space. 56:24.400 --> 56:28.840 So, you could say that, just to mention another notion, we talked 56:28.840 --> 56:33.200 about self-optimizing systems, so you would always, if we are at a 56:33.200 --> 56:36.540 certain situation, you would always assume that the self-optimizing 56:36.540 --> 56:41.240 system would try to improve its behavior such that it becomes 56:41.240 --> 56:45.920 completely acceptable and the system is in the target space. 56:46.640 --> 56:51.400 So, that would be self-optimization, moving systems into the target 56:51.400 --> 56:51.860 space. 56:52.780 --> 57:00.020 Robustness now means, how do we actually change the membership of 57:00.020 --> 57:06.480 states in those different spaces, target space, acceptance space, and 57:06.480 --> 57:12.320 so on, if a very well-performing system still is very well-performing 57:12.320 --> 57:16.800 after certain disturbances, then that's strongly robust. 57:17.020 --> 57:21.280 If it at least remains acceptable, it's weakly robust. 57:22.980 --> 57:25.840 Now, the next thing has to be defined, adaptiveness. 57:26.860 --> 57:31.460 Now, it may be that you have disturbances and you have a disturbance 57:31.460 --> 57:35.060 and your system is moved into the survival space. 57:36.760 --> 57:41.900 So, here the disturbances map the acceptance space into the survival 57:41.900 --> 57:50.940 space and from the survival space, as it is defined, you can get back 57:50.940 --> 57:54.700 in some way into the acceptance space by external control, then it is 57:54.700 --> 57:55.260 adaptable. 57:55.380 --> 58:01.520 This is consistent with what we have defined very early in the course. 58:02.340 --> 58:07.480 We talked about manageable or adaptable systems and we also talked 58:07.480 --> 58:14.200 about adaptive systems and we say that it is adaptive if it can be 58:14.200 --> 58:19.100 moved outside into the survival space but then it will come back into 58:19.100 --> 58:24.380 the acceptance space without external control by internally built-in 58:24.380 --> 58:28.960 control action, so that would be the self-healing aspect. 58:29.940 --> 58:36.540 So, then it would be called adaptive, it can come back into the 58:36.540 --> 58:41.460 acceptance space without external control actions, there is some self 58:41.460 --> 58:44.460 -healing aspect built into it. 58:44.560 --> 58:53.100 So, this would be self-healing in some way or you could also say self 58:53.100 --> 58:53.800 -stabilizing. 58:54.080 --> 58:54.240 Yes? 59:02.920 --> 59:04.280 Here's the other way around. 59:04.980 --> 59:06.260 Yes, you're right. 59:09.800 --> 59:16.000 Okay, you're right, this is something which is a little bit... 59:17.640 --> 59:29.640 you could say this depends on the system border, if the external... 59:31.240 --> 59:38.840 if the external control means that the user has to do something and 59:38.840 --> 59:44.720 then this system is adaptable, but you're right, it is like this 59:44.720 --> 59:50.100 initial notion of adaptive systems, this is a notion which is around 59:50.100 --> 59:55.560 in the literature, but we did not say... what did we say? 59:55.660 --> 59:58.740 We said manageable and self-managing. 01:00:00.720 --> 01:00:02.160 Yes, those were the two terms. 01:00:03.160 --> 01:00:05.400 We did not have the term adaptable. 01:00:06.280 --> 01:00:12.740 Yes, so I can get out of that by saying that at that point when we 01:00:12.740 --> 01:00:18.300 looked at the notions defined by Guillaume Mülle, we had adaptive as 01:00:18.300 --> 01:00:25.820 some more general term and then we had a distinction into manageable, 01:00:26.500 --> 01:00:34.060 self -manageable, and then we could say like adaptive, this can do 01:00:34.060 --> 01:00:35.000 something on its own. 01:00:37.020 --> 01:00:53.460 There are also other notions around self-stabilizing systems. 01:00:54.020 --> 01:00:58.320 This is a notion which is also around in the literature, has been 01:00:58.320 --> 01:01:04.800 defined by Dijkstra some time ago, a long time ago, and so these are 01:01:04.800 --> 01:01:08.780 other notions related to that definition. 01:01:09.920 --> 01:01:18.460 So, I think it's intuitively reasonable to define it in that way, that 01:01:18.460 --> 01:01:21.660 you say something, like if it does something on its own, it is 01:01:21.660 --> 01:01:26.820 adaptive, and if it's not capable of doing that on its own, we can 01:01:26.820 --> 01:01:30.100 adapt it to that new situation. 01:01:31.380 --> 01:01:37.740 And so, these other notions, self-healing, self-stabilizing, are also 01:01:37.740 --> 01:01:41.680 relevant or adequate, so there are different notions available 01:01:41.680 --> 01:01:45.460 addressing very similar topics. 01:01:47.080 --> 01:01:53.200 And now, I would like to show you two different aspects, like 01:01:53.200 --> 01:01:54.640 robustness versus flexibility. 01:01:55.100 --> 01:02:00.760 We have just seen definitions of robustness, and there we talk about a 01:02:00.760 --> 01:02:05.720 system, we have a certain disturbance, and we look at our 01:02:05.720 --> 01:02:10.060 classification of that state space, and would like to make sure that 01:02:10.060 --> 01:02:17.160 our system remains in the target space or the acceptance state, so 01:02:17.160 --> 01:02:18.160 that's robustness. 01:02:19.160 --> 01:02:23.360 Modification of state attributes without changes in objectives, the 01:02:23.360 --> 01:02:24.840 classification stays the same. 01:02:25.780 --> 01:02:31.240 Now, if we change the objectives, then something happens which is 01:02:31.240 --> 01:02:37.080 animated here, it means that if we change the objectives, our state 01:02:37.080 --> 01:02:41.560 space is, or the classification of the state space with respect to 01:02:41.560 --> 01:02:43.780 those criteria is different. 01:02:45.160 --> 01:02:50.900 And now, if we before had a system which was in the target space, it 01:02:50.900 --> 01:02:55.900 was perfectly well performing, all of a sudden, it might no longer be 01:02:55.900 --> 01:02:59.040 in the target space, but in this case, it would be in the acceptance 01:02:59.040 --> 01:03:04.360 space, still okay, but in order to get back into the target space, we 01:03:04.360 --> 01:03:07.620 would need to do some optimizing actions. 01:03:09.220 --> 01:03:16.720 And this definitely is a different type of requirement, because you 01:03:16.720 --> 01:03:20.200 may design a system such that it performs a certain functionality, 01:03:20.900 --> 01:03:25.780 even if certain parameters are modified in some way. 01:03:26.540 --> 01:03:32.040 But to ask it to perform another function might be very difficult. 01:03:33.000 --> 01:03:38.320 And so this is something, this actually is a different notion, which 01:03:38.320 --> 01:03:39.600 we called flexibility. 01:03:40.500 --> 01:03:43.500 You can modify the way the system actually is performing. 01:03:46.240 --> 01:03:53.140 And so that is, yeah, flexibility showing that you have to adjust the 01:03:53.140 --> 01:03:54.560 way the system is running. 01:03:54.560 --> 01:03:59.260 In the traffic light example, objectives, as I said, could be number 01:03:59.260 --> 01:04:01.740 of stops or the delay that you have. 01:04:02.460 --> 01:04:06.900 Different objective could be to have energy or to reduce the energy 01:04:06.900 --> 01:04:12.700 consumption, or to have some other things like you don't want to have 01:04:12.700 --> 01:04:14.560 too much traffic in a certain area. 01:04:15.480 --> 01:04:19.400 Different objective, you don't like, you would like to make sure that 01:04:19.400 --> 01:04:24.380 the number of cars going or running through a certain street is always 01:04:24.380 --> 01:04:25.700 below a certain threshold. 01:04:26.660 --> 01:04:30.700 Completely different objective, and then your traffic light settings 01:04:30.700 --> 01:04:34.420 would have to be modified depending on those new objectives. 01:04:37.520 --> 01:04:39.660 Then we could have further refinements. 01:04:40.260 --> 01:04:50.080 So we could say we have a certain situation, like a certain state, and 01:04:50.080 --> 01:04:54.340 I just draw it here in a way that indicates this looks like being on 01:04:54.340 --> 01:04:58.960 the corner of that state space, this target space or the acceptance 01:04:58.960 --> 01:04:59.400 space. 01:05:00.360 --> 01:05:06.240 Now, as I said, this is just some visualization having nothing to do 01:05:06.240 --> 01:05:10.640 with real neighborhood in the state space, but it may be what I would 01:05:10.640 --> 01:05:18.520 like to indicate is maybe that if we are in this situation, the number 01:05:18.520 --> 01:05:25.600 or the type of disturbances that we could accept are different from 01:05:25.600 --> 01:05:27.840 being in a situation like that. 01:05:29.000 --> 01:05:33.420 Or certainly here in the target space, if we are in the center, maybe 01:05:33.420 --> 01:05:38.400 it's more robust, the disturbances can be larger than in such a 01:05:38.400 --> 01:05:38.880 situation. 01:05:39.520 --> 01:05:44.320 So we could have more or less critical states which would lead us, or 01:05:44.320 --> 01:05:51.880 where disturbances would lead us directly out of the current sub-state 01:05:51.880 --> 01:05:52.760 or sub-space. 01:05:53.480 --> 01:05:56.420 So one could talk about some degree of robustness. 01:05:58.260 --> 01:06:03.880 And so we could have a radius of disturbance in the state space, how 01:06:03.880 --> 01:06:07.520 much are you actually changing, modifying the parameters, and what 01:06:07.520 --> 01:06:10.740 does that mean for the functionality that you still have. 01:06:13.080 --> 01:06:15.500 So this could be looked at. 01:06:16.460 --> 01:06:19.740 And then you could look at the radius of disturbance in the evaluation 01:06:19.740 --> 01:06:20.280 space. 01:06:20.800 --> 01:06:32.580 How large are the changes in the evaluation space that you have. 01:06:33.240 --> 01:06:37.180 And you could have different degrees of robustness depending on the 01:06:37.180 --> 01:06:41.400 number of disturbances or the strength of disturbances and things like 01:06:41.400 --> 01:06:41.640 that. 01:06:41.700 --> 01:06:46.120 If you have only very small disturbances, it's not as robust as if you 01:06:46.120 --> 01:06:47.980 allow even very large disturbances. 01:06:50.380 --> 01:06:56.520 So if I touch a certain device with my hand, it is robust to that, 01:06:56.580 --> 01:06:57.300 nothing changes. 01:06:58.420 --> 01:07:01.620 It will not break, such a plastic mouse here. 01:07:02.500 --> 01:07:10.160 But if I would get a hammer and use a hammer, then that will break. 01:07:10.360 --> 01:07:15.280 Or if I let my cup fall down on the ground, it will break. 01:07:15.920 --> 01:07:18.880 If I just put it hard on the table, it will not break. 01:07:19.560 --> 01:07:23.760 These are different degrees of robustness depending on the strength of 01:07:23.760 --> 01:07:24.320 disturbances. 01:07:25.600 --> 01:07:31.300 So you see that the notion of robustness is a notion which can be 01:07:31.300 --> 01:07:37.840 looked at a quite high degree of sophistication, different notions for 01:07:37.840 --> 01:07:38.140 that. 01:07:39.080 --> 01:07:44.300 I only define this notion that if you have a certain number of, or a 01:07:44.300 --> 01:07:49.740 certain set of disturbances, then we can look at what that actually 01:07:49.740 --> 01:07:50.200 means. 01:07:51.820 --> 01:08:02.000 Okay, so here I just indicated again our look at this traffic example 01:08:02.000 --> 01:08:08.500 where like you could have certain disturbances in your system, certain 01:08:08.500 --> 01:08:14.540 streets will be blocked, or other things might happen, a car might, or 01:08:14.540 --> 01:08:16.280 there might be an accident and things like that. 01:08:16.340 --> 01:08:19.980 Those would be disturbances, and then you have to look at how much 01:08:19.980 --> 01:08:24.360 actually your system is modified depending on those disturbances. 01:08:25.720 --> 01:08:32.640 And it's typical visualization of what robustness could mean is given 01:08:32.640 --> 01:08:37.260 by this diagram where I show you a very simple situation. 01:08:38.200 --> 01:08:43.260 We have just a function which we would like to optimize, a certain 01:08:43.260 --> 01:08:44.120 fitness function. 01:08:45.460 --> 01:08:49.000 So we are interested here in this case in maximizing the fitness. 01:08:51.400 --> 01:08:55.840 Now, our parameter that can control what the system is doing is the 01:08:55.840 --> 01:09:00.380 parameter x, and we have these two areas, or you could say different 01:09:00.380 --> 01:09:03.220 examples of fitness functions. 01:09:04.480 --> 01:09:11.260 So, if we just try to get the optimum performance, we would go for 01:09:11.260 --> 01:09:12.000 this value. 01:09:12.960 --> 01:09:19.080 Then we have the maximum level here, that's our best performing 01:09:19.080 --> 01:09:24.300 selection of the best performing system. 01:09:25.500 --> 01:09:32.100 But if we now have a deviation, any deviation in this case would 01:09:32.100 --> 01:09:36.760 result in quite a significant drop in quality. 01:09:37.240 --> 01:09:41.320 So here we would have, like that is the next one, a large drop in 01:09:41.320 --> 01:09:45.140 quality, we have a small change in the parameter, and a large change 01:09:45.140 --> 01:09:48.200 in the functionality, that fitness value. 01:09:48.200 --> 01:09:56.260 If we would have decided to take that parameter x at that value, we 01:09:56.260 --> 01:10:02.140 would not have achieved our best performing situation. 01:10:02.720 --> 01:10:06.860 So we would have this deviation from the optimum performance. 01:10:07.560 --> 01:10:12.560 But here, even if we have slight tolerances in that value, or some 01:10:12.560 --> 01:10:23.600 changes in that parameter x, we only have very small deviations from 01:10:23.600 --> 01:10:25.600 the functionality, from the fitness. 01:10:26.500 --> 01:10:33.820 And so here, small changes in the parameter will lead to very small 01:10:33.820 --> 01:10:37.540 changes in our fitness. 01:10:37.540 --> 01:10:45.820 So definitely this here would be a much more robust design decision 01:10:45.820 --> 01:10:49.860 than going for such a situation. 01:10:50.380 --> 01:10:55.140 And this is something which you will run into in many design problems, 01:10:55.320 --> 01:10:59.620 you may have some manufacturing process, and if you would like to have 01:10:59.620 --> 01:11:03.940 a robust manufacturing process where you would have to consider 01:11:03.940 --> 01:11:09.320 certain tolerances in some parameters, a situation where you have 01:11:09.320 --> 01:11:15.340 drastic changes just by small deviations in your design parameters 01:11:15.340 --> 01:11:17.540 would be very risky. 01:11:18.300 --> 01:11:23.400 So it would be more relevant or more adequate to go into something 01:11:23.400 --> 01:11:31.760 like this, where you go for a minor quality or minor functionality, 01:11:32.220 --> 01:11:35.560 slightly reduced functionality or maximum functionality that you can 01:11:35.560 --> 01:11:40.740 get, or maximum fitness, maximum quality that you can get, but a very 01:11:40.740 --> 01:11:41.640 robust situation. 01:11:41.640 --> 01:11:46.260 So the average quality that you get out of your process will be better 01:11:46.260 --> 01:11:48.220 than in that situation. 01:11:48.700 --> 01:11:49.340 You have a question? 01:12:02.720 --> 01:12:07.200 Okay, you mean that there we would stay in that area. 01:12:07.380 --> 01:12:10.820 Okay, I should have drawn it even in a different way. 01:12:11.460 --> 01:12:15.580 Yeah, certainly for that drawing you could argue in that way that if 01:12:15.580 --> 01:12:18.900 the deviation is quite large, then here you are still in that area, 01:12:18.900 --> 01:12:21.660 whereas there you would be even below that. 01:12:23.500 --> 01:12:24.960 Okay, you're right. 01:12:25.760 --> 01:12:27.800 So different design decisions. 01:12:28.360 --> 01:12:33.660 How far, how much actually is the disturbance that you consider? 01:12:35.180 --> 01:12:40.240 You have to look at the set of disturbances that you consider. 01:12:40.240 --> 01:12:45.160 So that determines how you can argue about robustness. 01:12:45.800 --> 01:12:51.900 And now you certainly have to argue about the average quality of your 01:12:51.900 --> 01:12:52.220 system. 01:12:52.740 --> 01:12:53.860 It depends. 01:12:54.500 --> 01:12:56.240 You can look at the average quality. 01:12:56.500 --> 01:13:00.360 In some situations you would like to argue about the maximum deviation 01:13:00.360 --> 01:13:03.220 that you actually get in your fitness or in your quality. 01:13:03.920 --> 01:13:06.600 You always like to have a minimum level of quality. 01:13:07.560 --> 01:13:12.860 So many things that you can look at, but I think the meaning or the 01:13:12.860 --> 01:13:17.420 idea that I wanted to get across should be clear, should be obvious. 01:13:18.240 --> 01:13:25.260 And so it definitely shows that you have to look at the size of the 01:13:25.260 --> 01:13:30.980 disturbance and the effect that this has on the quality of your 01:13:30.980 --> 01:13:31.460 system. 01:13:31.460 --> 01:13:36.180 And so if it is changing dramatically, it's not robust. 01:13:36.860 --> 01:13:38.640 At least for that disturbance. 01:13:39.800 --> 01:13:46.400 Okay, another point is that sometimes you not only have the robustness 01:13:46.400 --> 01:13:50.120 to consider, but you might have some other constraints which say, 01:13:50.120 --> 01:13:56.340 okay, I have some additional constraints which define the feasible 01:13:56.340 --> 01:13:58.980 region for my system. 01:13:59.700 --> 01:14:06.260 I have certain other requirements which tell, okay, it's not adequate 01:14:06.260 --> 01:14:10.200 to be outside those constraints. 01:14:10.200 --> 01:14:16.880 And so it's only adequate to have values for my function which are in 01:14:16.880 --> 01:14:18.920 this area here, that's the feasible region. 01:14:19.700 --> 01:14:21.540 And beyond that, it's not acceptable. 01:14:23.040 --> 01:14:27.480 And now you have another criteria to look at. 01:14:27.740 --> 01:14:31.800 You certainly would like to have a design which is feasible. 01:14:32.960 --> 01:14:39.040 That just looks at effectiveness or the reliability of a design. 01:14:40.220 --> 01:14:43.160 The chance of failure of the system is very low. 01:14:43.160 --> 01:14:50.640 Even if you have certain changes, you would not get into a situation 01:14:50.640 --> 01:14:53.480 where the system is no longer feasible. 01:14:54.700 --> 01:15:00.820 So if you would have a design at this point, a small change might lead 01:15:00.820 --> 01:15:02.700 you out of the feasibility space. 01:15:02.700 --> 01:15:07.480 If you have something which is there, it's still feasible. 01:15:08.480 --> 01:15:14.240 And even changes, quite large changes of your parameter x would still 01:15:14.240 --> 01:15:17.300 leave you in that feasibility space. 01:15:18.880 --> 01:15:23.020 So here I have slightly other drawing. 01:15:23.240 --> 01:15:31.060 Here we look at the state space. 01:15:31.640 --> 01:15:33.880 We have two parameters, x1 and x2. 01:15:34.540 --> 01:15:36.440 And we look at the different states. 01:15:36.800 --> 01:15:44.600 So maybe these are regions of the same fitness. 01:15:45.580 --> 01:15:49.480 So the closer we get here, the better is the fitness, the quality. 01:15:50.460 --> 01:15:53.880 And certainly we would like to get actually in the area where we have 01:15:53.880 --> 01:15:55.300 the best quality. 01:15:56.180 --> 01:16:02.340 But other constraints tell us that that's no longer feasible for that 01:16:02.340 --> 01:16:02.920 system. 01:16:02.920 --> 01:16:09.680 So the deterministic optimum would be exactly that one. 01:16:10.780 --> 01:16:17.580 But a reliable solution, which will still be feasible even if we have 01:16:17.580 --> 01:16:23.320 certain changes, would be a solution which would be at some distance 01:16:23.320 --> 01:16:25.780 from those different constraints. 01:16:25.780 --> 01:16:32.940 So even if parameters x1 and x2 are modified depending on the 01:16:32.940 --> 01:16:39.280 neighborhood that we defined there, the larger that neighborhood is, 01:16:39.420 --> 01:16:42.680 the more reliable we would say that system is. 01:16:43.440 --> 01:16:46.060 So this is another aspect that we have to look at. 01:16:46.500 --> 01:16:51.260 Not just fitness with respect to certain objective function, but also 01:16:51.260 --> 01:16:54.100 the feasibility can be important. 01:16:59.260 --> 01:17:07.040 For example, you say that you would like to get from city A to city B 01:17:07.040 --> 01:17:14.140 and you try to optimize that and you go with the maximum speed all the 01:17:14.140 --> 01:17:14.520 time. 01:17:14.840 --> 01:17:15.840 That's not allowed. 01:17:15.840 --> 01:17:18.980 There are certain requirements that tell you there are speed limits 01:17:18.980 --> 01:17:26.260 and then you have to make sure that your car is always driving inside 01:17:26.260 --> 01:17:27.900 those speed limits. 01:17:28.900 --> 01:17:29.660 Okay. 01:17:30.640 --> 01:17:41.620 Now, this is just some ideas about robustness, flexibility and 01:17:41.620 --> 01:17:42.300 reliability. 01:17:43.220 --> 01:17:51.620 And now, if we talk about a system which is in some way dynamic, there 01:17:51.620 --> 01:17:55.500 are certain disturbances in control theory. 01:17:55.920 --> 01:17:59.220 We always talk about getting feedback. 01:17:59.220 --> 01:18:03.400 Certainly, like I said, a system is adaptive or adaptable. 01:18:03.900 --> 01:18:07.500 It can only be adaptable if we notice that something has gone wrong. 01:18:08.300 --> 01:18:13.420 Then we have to give feedback to the system to modify its behavior. 01:18:14.060 --> 01:18:19.860 In control theory, this is usually just modeled as this. 01:18:19.940 --> 01:18:23.560 We have a certain process, we have disturbances, we have input, we 01:18:23.560 --> 01:18:25.620 have a control system, we have the output. 01:18:26.500 --> 01:18:31.740 And now, we have to talk about how to give the appropriate input or 01:18:31.740 --> 01:18:37.960 the appropriate feedback such that the process is stabilized. 01:18:38.560 --> 01:18:44.580 If the output deviates from what we have expected, this is fed back 01:18:44.580 --> 01:18:49.040 into the system and should result in corrective actions. 01:18:50.100 --> 01:18:54.480 And there are some standard approaches to giving feedback. 01:18:55.400 --> 01:18:59.860 One is to give positive feedback, the other is to give negative 01:18:59.860 --> 01:19:00.480 feedback. 01:19:01.400 --> 01:19:06.960 Positive feedback would mean that the feedback of the system 01:19:06.960 --> 01:19:11.400 influences the output or the process in the same direction as the 01:19:11.400 --> 01:19:13.660 preceding observed changes. 01:19:13.660 --> 01:19:21.060 So, if some value at the output gets larger, the input would give some 01:19:21.060 --> 01:19:23.800 positive feedback, would go into the same direction. 01:19:25.220 --> 01:19:29.920 And obviously, if something goes into this direction, you would 01:19:29.920 --> 01:19:36.400 increase that actually, and so a certain value would get even larger. 01:19:36.400 --> 01:19:43.160 Or if it would decrease, you would decrease it even more, and you get 01:19:43.160 --> 01:19:48.600 some exponential growth or decline, some diverging behavior which is 01:19:48.600 --> 01:19:49.240 not robust. 01:19:49.380 --> 01:19:53.120 If you just have positive feedback, you don't get a robust system. 01:19:54.120 --> 01:19:59.880 If you have negative feedback, then you would say, if I see a certain 01:19:59.880 --> 01:20:04.480 output, a certain change in the output, I give negative feedback, some 01:20:04.480 --> 01:20:12.740 input such that this modification is reversed. 01:20:13.480 --> 01:20:20.000 And so it would go down, like if this is the goal, if it goes into 01:20:20.000 --> 01:20:23.880 that direction, I would like to give negative feedback to move it up 01:20:23.880 --> 01:20:24.260 again. 01:20:24.900 --> 01:20:31.000 If it exceeds the value, I would reduce it again. 01:20:31.620 --> 01:20:37.200 If it gets smaller than that value again, you would increase it again, 01:20:37.260 --> 01:20:37.740 and so on. 01:20:37.740 --> 01:20:43.280 And in this way, you would have some way of actually getting some 01:20:43.280 --> 01:20:50.560 stable value that is your goal in that situation. 01:20:50.660 --> 01:20:58.980 So negative feedback usually is made in order to reduce the dynamics 01:20:58.980 --> 01:21:04.020 of such a system parameter, as you see in this example. 01:21:04.020 --> 01:21:06.840 So it's about maintenance of equilibrium and convergence. 01:21:07.280 --> 01:21:11.780 Now, in control theory, there are many approaches how you can do that. 01:21:12.200 --> 01:21:20.980 I don't go into those details, like all kinds of controllers, PID 01:21:20.980 --> 01:21:23.640 controllers and things like that, which you might have heard of. 01:21:24.360 --> 01:21:30.260 I will in a moment go, or not today, but next time, go into the model 01:21:30.260 --> 01:21:34.980 predictive control approach, which is a specific approach for giving 01:21:34.980 --> 01:21:36.100 feedback to a system. 01:21:36.100 --> 01:21:40.040 Just an example of positive versus negative feedback. 01:21:40.560 --> 01:21:44.960 If you have a certain amplifier, you have some reference signal, and 01:21:44.960 --> 01:21:55.620 the amplifier is working, and the positive feedback would be that, 01:21:55.820 --> 01:22:03.000 like this would be negative feedback, you would reduce the amplitude 01:22:03.000 --> 01:22:11.360 here, and positive feedback, if the amplitude gets larger, you would 01:22:11.360 --> 01:22:12.420 even increase that. 01:22:12.420 --> 01:22:16.200 And so with positive feedback, you could increase the amplitude, with 01:22:16.200 --> 01:22:18.300 negative feedback, you would reduce the amplitude. 01:22:19.080 --> 01:22:24.560 Very simple example of positive and negative feedback. 01:22:25.760 --> 01:22:30.140 And the next topic that we will look at is model predictive control, 01:22:30.820 --> 01:22:39.200 which is a very active area of research in control theory, and a quite 01:22:39.200 --> 01:22:41.580 flexible way of controlling systems. 01:22:42.420 --> 01:22:48.840 And in some way, quite some similarity with our approaches to the 01:22:48.840 --> 01:22:53.340 design of organic computing systems, like the MAPE system, or the 01:22:53.340 --> 01:22:57.780 Observer Controller system, could also be seen as model predictive 01:22:57.780 --> 01:22:58.280 control. 01:22:58.520 --> 01:23:02.060 Or you could say that model predictive control is some way, or some 01:23:02.060 --> 01:23:06.780 design, which is similar to what we have in MAPE or in Observer 01:23:06.780 --> 01:23:07.240 Controller. 01:23:07.240 --> 01:23:10.180 So we will look at that slide next time. 01:23:10.300 --> 01:23:15.500 Again, this is just explaining some essential points about model 01:23:15.500 --> 01:23:18.920 predictive control, and on the next slides we will see the system 01:23:18.920 --> 01:23:19.360 structure. 01:23:19.780 --> 01:23:20.860 Okay, that's it for today. 01:23:20.980 --> 01:23:21.780 Thank you for your attention.