 Then the other thing we see here is for both of our convolution layers con zero and con one We have snapshots at a hundred thousand time steps and two hundred thousand time steps so here we can see in our con zero layer the way we can read this is we have each of our Kernels here's the shape that those kernels take and then you can see the signal and Based on the opacity the darkness of the signal you can see where that Kernel best matched where the convolution value was high so for instance This particular Kernel had a pretty high match right here at this value This particular kernel had a high match at this value so you can see what matched where This particular kernel had high matches for these zero values here This is like a heat map that lets us see which Kernel responded most strongly to which positions in the signal and Then we also see the output biases which in this case all stayed pretty close to zero This makes sense since the inputs were all pretty close to zero or average to be zero and we can see how this Changed Here it just so happens that this was compared at the 200,000th time step it was compared against a different set of outputs And we can see which respond most strongly so here's our signal This is it an M You can see the up down up and you can see this particular kernel Responded very strongly to portions of it whereas say this kernel here Responded almost not at all to any bit of it this kernel here You can see responded especially well to the divot at the center, which is the inverse of the divot of that kernel So you can start to see which of these pieces respond most strongly to which of our flavors of blips Now if we look at the output of our Conv1 our second convolution block we can see a similar thing the difference here is we have more Channels we have more kernels in this case 12 kernels and Each kernel is longer instead of being five elements long these are seven elements long and You can see also the outputs now the biases I should say are not zero They tend to vary quite a bit and you can see for this particular Signal that there are different kernels and different channels that responded most strongly So this channel is one of the strongest responders and you can see that across this channel Quite a few of these kernels responded strongly to different parts of it Similarly for this channel so for Conv1 for our second Convolutional block you can see now we have a multi-channel input There's one channel here for each of the kernels in Conv zero here. We had five by three 15 kernels that generated a 15 channel signal now we have all 15 channels and They are being passed through six by two or 12 kernels and you can see that this kernel in particular Tends to respond very strongly Across all of these channels as does this one here Whereas this kernel responds almost not at all same with this one here You can also see that the output biases here are not zero There's a lot more variance and a lot more structure to them and then similar patterns hold as you move further on in time Here as we track the loss over time you can see that Initially, there's a very steep descent as the kernel weights Settle into values that lets the network distinguish between the different flavors of blips By the time it gets down to the end of its training at a hundred thousand iterations It started to slow down in its descent. So this is the Base ten log of the loss. So this is where the mean squared error is point one This is where the mean squared where error is point oh one and it's but it is continuing to go down If we let it continue to train it would probably get Lower to maybe even minus three point oh oh one but we freeze it here and then run through an evaluation period where we don't update any of the weights anymore and As expected it stays at a fixed value with some deviation So this is a big deal. This is a big milestone. We've taken now and implemented a convolution block and Within the cottonwood machine learning framework. We have taken and built a whole signal recognition Task using our blips data set and shown that it works. So this is a little end-to-end test It's useful enough in fact that I've taken and reduced the scope of it and added it to the set of tests They get run automatically on cottonwood when I want to make sure that it works when I've changed something And I want to make sure I haven't broken it. This is one of the tests that it will then run now Where there are a couple of pieces missing and in our next section will add those in to make this a fully fledged grown-up convolutional neural network