Data Science is More Than Just Statistics

Both of the streams get going properly and everyone joins and then we'll get going. And the general idea for today is I'll show basically some examples mostly of how, how most people's perception of data science being just this, this sort of statistical operation on data is. It can be kind of incomplete and there's a lot more that we can do that we could class as data science and. And on top of that we'll show how that fits in with our technology stack and how you can do all of this very easily inside Mathematica. So we can get started now. So as I've been saying. So is data science just statistics? Is it just. We've got a bunch of, you know, a collection of numbers, a collection of data and we, we, you know, extract some kind of statistic metrics from them and. Yeah, it could be, but I would go out and say that data science is just any sort of computation with data, right? Computing with data. We could class as data science and that computation could mean anything, right? So computation can mean that those statistics operations, or it could be modeling the system, it could be visualizing the system or it could be training a machine learning model on the system, doing signal processing on the data, you know, extracting geometry and doing image processing. All of that can be classed as data science to an extent because we are sort of operating, we're computing on, on this, on this data. So we're going to start out with our examples and the general structure for today is going to be bunch of examples of different ways we can use computation with different data and things we can do. And during that, if there's any questions, obviously feel free to put them in the chat. I'll be monitoring the chart as we go. So we can start off with. So getting counts for things, right? Finding things to count. And we can start with some text. So in this case we'll do some word frequency analysis for the Lord of the Flies and we can open up the code here. So we're going to start out with just this string for the book, right? This is just a big long string of the whole text of Lord of the Flies and we're going to define that as this lotf variable. Then we're going to create a helper function that creates this, that creates a plot name and it's just kind of helper function to finally generate this word frequency plot, right? We just. So let's walk through it. Let's, let's do this. So we are so plot name, just plots, a histogram, a smooth Histogram of the data that we ask it to or the word that we're looking for. So in this case we're looking for beast, mentions of beast, mentions of Jack and mentions of Ralph in the text. And then this will create these overlaying smooth histograms of the, the frequency of occurrence of those words throughout the Lord of the Flies text. So we can see kind of, we can, we can already start grabbing some insights of our data. So we can see Ralph is kind of. That there is peaks to his mention at the start and end of the text, whereas the beast, there is this, you know, slight foreshadowing in the beginning of the text. And then later we get this peak of, of, of, of, you know, a lot of mentions about this, this beast in the climax or middle of the book. Right. So we can continue and do some sentimental analysis as well. So instead of just looking at the words, we can look at the sentiment of sentences. So if, you know, if sentiment, if sentences are positive or negative. So in this case we will use classify, our built in classify and we can give that a. It has this sentiment form built in and we can, if we construct this classify form using sentiment and give it a sentence and then we can tell it what we want. We wanted to give it back. In this case, it's going to give us a list of the probability and the probability of it being positive. Right. And we're going to find, we're going to do the maximal by, to all of our sentences inside a lot of the flies. So what we're going to do, we're going to take a lot of the flies, separate all the sentences out into different strings, put them in a big list and then we're going to use this classify to find the maximal positive positively sentimented sentence or the sentence that is most likely to be positive in the book. And if we define a lot of this stuff, so let's start defining it. So here we go. And then we can run this. So a lot of this obviously has already been run, but we can see that when it goes through all the sentences of the book, it can pick out we are going it, it's going to do it again. So it picks out. We are going to the island, we're going to have lots of fun as the, as the maximal sentence. But what he's doing here is running through these operations, running through every single sentence of the book, checking its sentiment and then grabbing the maximal probability of those. And in this case, again, we are going to have fun on this island. Is the most surefire positive sentence in the whole of the text. We can overlay some stuff as well. So as we were doing before, we can take our smooth histograms and overlay more data on top of it. So we use this show, the show functions and show can contain any, any graphics and plots within it that will get kind of overlaid. So in this case, we're taking our first plot. So this is our initial plot that we made and we are showing that and then we're creating a second plot of. I think this is a sentiment throughout the text. So we're constructing here a list plot of, you know, we're going through and grabbing the sentiment of each of the sentences throughout the text basically and ascribing them with some given values. Right. So the idea is we plot our word frequency analysis and we also have this idea of sentiment, whether the sentiment of the text is positive or negative throughout the book. Right. And these are kind of, you know, these are pretty big insights that we wouldn't get from just looking at the raw data. Right. So quick question, someone asks what programming languages, what programming language this is? And this is the Wolfram language. So this is our own programming languages language called the Wolfram language. Or it's, it's also often called Mathematica, although the way that works, we've kind of changed it to where Mathematica is the software that I'm using right here. So this, this software that you see all these graphs and all this code written in and this slideshow being made in, that's Mathematica. And Wolfram language is the actual language that enables all of the, all of our kind of technologies, all our technologies are based on the WOLM language. So thank you for that question. And let's move on to some images. So we've done some analysis on text. Now let's do some analysis on some images and going to move it to some more scientific, to a more kind of scientific workflow here. So what we've got here is some nanoparticles embedded inside a medium. It doesn't really matter what the nanoparticles are or what the medium is in this case. We're just using this to show kind of the analysis that we can do on this stuff and the almost automation that we can achieve. So here's our nanoparticles that are embedded inside the medium. We can define this as the image variable. So if we execute this, we'll have this image variable and we can now do a bunch of things to it. Right. So we can rasterize the image first of all to just show this a little bit. So we're just showing this snippet of the image. We can clean the image by. And this is the whole code that goes into doing this, by the way, is these single lines. So here we're going to binarize the image and delete any small components inside of that to get rid of any noise. So here it is. This just automatically uses these built in functions and binarizes our image for us. And if there was any small components due to noise, it will just use this delete small components to get rid of them. We can work out the distances, so we can work out the distance transform on this binarized image. So we're going to negate that image to turn all the black areas into white areas and all the white areas into black. And then we're going to find the distance transform of that, which is the distance from each point to each other point and put that into an image. So here that is, here's all our images, all our distances. Sorry. And then again, we can find our maxima. We can use this. So each, each of these steps, we've been taking the previous step and using it for our next step, right? So we take our original, we clean it, binarize it, then we work out our distances. And then using these distances, we can finally use max detect on those and find our center points, right? So we can find our maxima in this image. So what we've effectively done is, is we've written an algorithm that can go through and find the seed points on the center points of each one of our particles that are embedded inside the medium. And now we can make use of that. I can put all of that together inside this plot where I can get an image out with a white X plotted on top of each particle, right? So instead of, of having some, some poor, like undergrad student go through and count these particles, we can instead write an algorithm that automates that and counts these particles for us and not just counts them, but we can go further than that and we can, we can compute distributions, right? So I can see, I can plot these inside a histogram and see the general distribution of these particles inside the medium, right? So we can get this 3D histogram of the distribution of these particles throughout the image. Let's continue on. So let's move on to, We've done some count stuff, so that was mostly, you know, counting things. And now we'll, we'll do inject in Context which is, you know, taking data that is contextless, that is just, you know, pure data and then extracting some kind of, or injecting some kind of context to it to extract an insight. So here our first example is using some London bike data. So there is an online data set that contains every, I think it's parked bike, I think it's like chained up bike in London. And we can see that it, it will kind of give the number of bikes I've given a longitude, longitude and latitude points, so a specific geopoints, how many bikes are there basically, and a general timestamp and a bunch of other identifying information. So we'll use that data to kind of extract some, some kind of insight about, about, you know, highest, higher bikes in London. So here we're going to import that data as JSON. We're going to convert it into an association, which is our, the native Wolfram language data format that is equivalent to sort of a dictionary in Python or equivalent to JSON in JavaScript. So we can convert that into an association of key value pairs and then put, finally put it inside a data set which is again Wolfram language data format. So if we do that, we can get this nice data set out where we've got different columns for each of our identifiers. So we've got the number of bikes, the name of the street, the latitude, the longitude and the other identifying factors and we've got them all in a data set that we can query. So this data set can actually be queried using SQL like queries and we can, you know, string those queries together if we want and do a bunch of, a bunch of useful things with the data in this format. So in this format is much more useful than adjacent string, for example. So here, for example, we're going to plot everything, we're going to take all this data, we're going to use our geographics within the Wolfram language. So Wolfram language already knows about geography, it already has these maps built in and I can give it a geopoint and it knows where on earth that is and it can plot that. So what we're going to do is we're going to use this data set here to plot each instance of this data onto a map and color code, each data point with the number of bikes that are present at that geopoint. Right. So we can get this geoplot R where we can get a general idea of the distribution of our, of our bikes throughout London. And we can see, you know, the closer to central you go the higher the number of bikes, you know, that are left around gets. But yeah, we can get a general idea of our, of our, I guess, general bike distribution and this we don't have to use points. We could do a heat map style style plot which will show with our food hygiene data. So again, as before we can grab our data in, so we kind of skipping that part. So in this, in the bike part we showed that you can just use import and import from an online data store in this case, or even you can interface with APIs if there's any API that serves the data that you need. You can also interface without using a URL execute. But it's always useful to get whatever data we import in into these data sets and then we're going to go from there, basically. So again, we've got this food hygiene data for the uk. So the uk, each food establishment has a food food hygiene rating out of five. So it's from zero to five. And that's publicly available information. There's a big data set of every restaurant, its location, its writing date and what rating it got, and so on. So we're going to take that data and use it to kind of try and pick out trends in the data. Right. So the first thing we're going to do is we're going to just take the data for Oxford and here is the data for Oxford plotted. So here we've got the key. So the greener it is, the higher the food hygiene rating. And we're not really seeing much of a pattern here. We can also plot it in a heat map style map. So instead of plotting each data point manually, we can get these distributions of this visualization of the distribution of food hygiene. And we can get, we can get an idea of these, there's these small, there's these areas that get a decrease in food hygiene for whatever reason. And then we can do that, we can kind of generalize that out to the national, to the national data and use all the data in the UK and get a big heat map basically of the, of the food hygiene ratings throughout the uk. And now we do see a pattern, so we see a patent that the closer you go to higher highly populated areas, so London, Birmingham, Cardiff, Liverpool and Manchester there. So like the more highly populated these places are, the lower the food hygiene tends to get right again for whatever reason. But that is a trend that we've kind of been able to extract out by doing this kind of visualization. We can also plot this so we, we pick out this trend, we see okay where we around these settlements with, with, with large populations we get these dips in food hygiene. So let's actually plot food hygiene against population to see that trend. And then here we can kind of clearly see the trend of you know, lower population towns tend to have a larger proportion of, of high, highly food, highly rated food places. I think that would, that probably my guess is it, it's just the more restaurants you get the, you know, the, the more you're kind of quote unquote watering down the, the data and then you get in more of these lower hygiene standard restaurants. And I'd imagine poverty also plays a huge role in, in that. So let's keep moving. So we can keep doing this, let's go back so we can keep kind of generalizing this, this idea and keep doing this with different data sets. It is the same general idea that we're doing over and over but we're using built in tools right. So we're not downloading these maps, we're not overlaying anything like that. We are just using these built in functions to, to do these extremely involved things in a way that's not really involved at all. So anyway, so let's look at London car accidents. So I think this is. Or not or just accidents in general, road accidents. So here's our data set. We got geopositions which again Matthew Markin knows about. We, we natively can plot them on a map. We've got our dates here, the severity of the, of the accident, the types of vehicles that were involved, the ages, class severity again for some reason and the. Oh I see. So we've got another row for all casualties, all casualty data. So let me. So before we move in, move on from this, there was a couple of questions about the food hygiene data. So the source of this, I think so the Food Hygiene Authority kind of makes this stuff public. It's not particularly important where this data comes from for this sense. We're kind of just using it as a, like an example of hey, if you've got a bunch of data like this, here's what you can do with it. But just so I can see if I can give a better answer than that. So yeah, so the Food Standards Agency I think has a big data set that you can download with all the ratings for all the restaurants. Can we see the code for this? So yeah, we can show some code if the if. So some of these don't have any code. So this stuff we can walk through the code. These examples do not have code because these are kind of pre rendered. A lot of these take a long time to run and are pre rendered but we might, for some of them we might have the code to show a lot. So for this one I think, think yeah, we might have the, the actual code to show. So to answer your question, when I can show code I will. And if you are going through this notebook, so if you've noticed that I keep checking these, these side brackets here. So if you, if you see these, this arrow bracket here, if you double click that, it means there's hidden data and it will like expand out and open the data. And a lot of the times with these outputs we'll hide out, we'll double click it and hide the code. So you only see the output cells. But with a lot of these, yeah, you can double click on them. So like this, like these for example, you can double click on them and show these, the, the hidden code that kind of generates them. So just reading through some more questions. So is it, is it possible to edit the data in that nice table after it was imported? JSON. So you're talking about the data set and yes, that is the view of the data set. So these tables are just how data sets are displayed. So if you let me open the documentation for this. So if you put anything in the form of a data set, which data sets are just collections of associations and lists. Right. So they're just a combination of two other data formats within the Wolfram language. And this is what they look like when they get rendered out by the front end. But again we can also, they are like a data store sort of thing where we can query using, you know, SQL like queries. Yeah, they kind of automatically get put in these neat tables if your data is structured enough for that matter. So obviously the prerequisite is your data needs to be structured in a certain way. Right. It needs to be structured inside an association, first of all to give information of what is your columns, what is your rows. Right. But once you structure it in that way, dataset kind of just does the rest. So you cannot edit the data in the table. However, what might be useful to you is if I can remember, is it table. It's not table form, it might be table form. It is not table form, it is table table view, that's it. So table view will create these spreadsheet like Excel, like tables. That way you can actually go in and edit. And I'm pretty sure, don't quote me on this, but I'm pretty sure you can natively copy and Paste these cells into Excel. But is it? Yeah. So yeah, for data set, these data sets, you can't actually use the GUI to edit the, the data. You just look at it. But if you do want that kind of functionality, this table view is a function that you should look at. Okay, let's keep going. So will kind of graze over this because I spent quite a bit on, on everything. So let's fair show what we're doing. So we're taking our, our accident data. We are plotting it on, onto the map. We're just plotting the GEO positions here on the map. So that should be this one. So here we are creating geomarkers for each geolocation and just plotting it on this geographic which kind of knows what, what map to use and everything. We can then instead of a geo, instead of a, instead of points we can use a histogram, so a geo smooth histogram to then get a distribution or, or visualization of the density of, of accidents. And we can see this, there's a particular hotspot in this intersection here for road traffic accidents and these intersections for example. And we can also just see these binned histogram views. Instead of a smooth histogram, this is just a GEO histogram which bins discrete regions of the map and has a look how many, how many occurrences of the thing that you're counting is within that, that bin. So let's actually walk through the, the, or try to walk through the, walk through the code a little bit. So here we put in the data from an MX file, which I'm not going to do because it takes a long time. Here is a helper function to work out the color of, of our plot. So our initial plot we see we've got different colors depending on severity. And this is what this function does. So it checks for our type. And if it's slight it's green. If it's serious it's gray and if it's fatal it's red. We give a range constant here of 1.2 miles, which I think is just used for our plotting range. And here are some options for our plots which we can ignore. These are basically theming options. So how big the image is and how big our GEO range that we're plotting is. Here we're extracting our, our venue. So here's just a geoposition for that. We're manually inputting ourselves for a specific place for our venue. Here we're extracting local accidents from our accidents. So accidents is the big data set that came in and then we can use this, this query within it to select any, we are selecting any distances. So data set queries can also be pure functions. So they can take those, those entries and do logic checks on them or operate on them in some way. So in this case we are going through our data set and selecting any, we're selecting any values that the geo distance of that geoposition from from the venue is less than our 1.2 mile range, right? So we can do this, that we can add this query of a pure function where it will go through our data set and kind of we don't have to do an extraction step and an operation step. We can just kind of combine those two and do them together and select only specific, only specific entries from our data. So here's, we're creating a marker, so here's just a geomarker for, for our venue, right? So we're just going to place a marker down where our venue is so we know where that is. And here we are constructing our plots. So our first plot, this one, it is a geographic with all our markers on there. So here's the market for our venue and it has a point size of this. So that's our graphic directives for those. And then we've got the normal of all our local accidents. So the local accidents we extracted, we're grabbing all of those and we are putting severity, this is the severity column, we're putting that inside this color function to work out our color. And we are also putting the geoposition inside a point function. So so we are constructing our graphic directive for each point of the local accident. And these are just our options for our geographic so general theming options. And that is the first plot. And then the rest of them are kind of the same general idea where we pass these local accidents, we pass different columns from that data to different functions. So geosmooth histogram takes all the geopositions and plots those for us in inside this heat map style visualization. And we'll, we're also showing our venue marker. And then finally we, we, we do the histogram, the geo histogram of our, of our final plot which is this plot three here. So this geo histogram where we give all our geopositions to geo histogram instead of geo smooth histogram. The only difference is one is bend and one is smooth. Someone says so the reason could be bad road design or density. Can we know the most affecting reason from just raw data? I think so. Let's have a look at our data and see what we have. So I think, I think from this data we probably couldn't deduce any reasons I, aside from looking at. So you, what you could do from this. You could look at the ages involved and be like, okay, there is a correlation between young people crushing on this interchange. Right. Or there is a correlation between cars or buses crushing on this particular road. So we, you have to kind of look at the data you're given and see what, what you can get from it. Right. So there's only specific data that we have here, therefore there's only specific insights that we can extract. But yeah, reasons we can correlate stuff. I don't know that we can necessarily pick out a reason though. Yeah, I'd say probably just correlate. Here's a final example that I'll, I'll really kind of rush through of shipwrecks. Here's a big data set of a bunch of shipwrecks. It is the, each column we've got a column for ship name. So just the name of the ship, the day on which is sunk on. And I think these are in string format a description of the ship. So what it was. And I think, yep, how it's sunk as well and its coordinates as well. So here we've got its geolocation as well. Right. We've got about 530 entries for that. So first thing we want to do is do something a little bit less quantitative and a little bit more qualitative. So quantitative visualizations are incredible. You know, we're, we're, a lot of us here are probably, you know, tech based or science based. I know I am. So I, I do, you know, have a weak spot for quantitative visualizations. However, qualitative visualizations also are very useful. So things like word clouds, which are kind of a combination of both. It is quantitative in the way that it shows you the frequency of use of words, but it's also sort of a nice sort of pretty visualization to get an idea of your data. In this case we are giving this word cloud function built in function inside Mathematica that takes lists of words or a text and kind of construct these word clouds where the size of the word is dictated by the, by the frequency of its use inside the text. So here we're just giving our Rex, we taking the description from those recs and creating a word cloud from that. And we can see that the most common word inside this, this data set is U boat. So I'm, I'm assuming what that is is a lot of ships that were sunk by U boats, which is what we'd expect for Europe. And we can also plot that and here is exactly what we expected from, from this. So we, we picked out the U boat, World War II German submarines, and here we are. The, the majority of of shipwrecks in this data set are from the 1940s. So we, we're starting to kind of pick out a, A, a pattern from, from this and here we can plot this, we can plot the geolocation and we see, you know, they're, they're kind that they're wildly distributed. But there is a hotspot of, of wrecks around the UK and if we show them inside a smooth histogram then we definitely see the pattern of most, most wrecks being centered around this, this specific area here. And the reason for that and what we can kind of pick out from this example is that oh, those are all the boats that were sunk during World War II, during the embargoes where, where Germany was kind of sinking ships that were going from say America to the UK bringing supplies that were being routinely sunk by, by the Germans. And so we've got this, this kind of area here where we've got a lot of World War II wrecks that are contained within this data set. So here's some more analysis that we can do on this. So we can grab also we, we can use the, the geographic, the geographic data that Mathematica already knows about. So all our geopositions we, we know we've got geo elevation data for those geopositions. Right. So we can, let's see. So yeah, I don't actually have the data with me right now, but when I send this notebook out the data. Yeah. So the day is not in my file right now because I pre generated all of this. But the general idea is there's a few more examples of kind of using the built in knowledge in Mathematica. This built in knowledge of geolocations, of geopositions and of, of elevation data and having this elevation data for every point on the Earth. So we construct these. We, we get this C data for all our elevation data around our, our Rex and we kind of construct this. The general idea is to construct this plot this 3D plot of all our shipwrecks in the geographic positions in 3D space. Right. So we, we actually plot them here in, in a 3D plot where the depth information is also retained. Let's see if there's any questions I missed before I go on with the supersonic car example. So someone put in a URL for the food hygiene data in big marker. I think we can share that. So someone said, I understand you use capital letters for the operators embedded in Mathematica and small letters for the introduced operator. So yeah, the general idea, let's. Let's just give a quick little kind of intro on that. The general idea is that any built in function in Mathematica starts with a capital letter. So plot starts with a capital letter plus capital letter. Any built in function starts with a capital letter. And it is because of that convention to any, any user defined function. So any function that you are defining yourself that is not built in to actually define using small case characters. So if I was making a custom plot, I would, I would name it like so custom plot. And you'd use camel case as well, which is customary in the Wolfram language. So this is kind of the general idea of, of. Of user defined functions starting with a, a lowercase letter instead of a capital. And I think that's it for now. Yep. All right, so let's do an example about kind of getting a different viewpoint from our data. And we'll use here some data from the supersonic car, which I forget the exact name of, but this is data from this RPM data and suspension load data from that. Right? So we've got our velocity data and we can use calculus. We can apply some calculus to it to grab our acceleration and we can move further to add our throttle response onto that, right. To get an idea of how our throttle response corresponds to acceleration. We can also apply some signal processing to our very noisy suspension load data so we can make this spectrogram of our data to get a better idea of where our load is kind of focused. And we can also change our dimensions. So in this case we can plot the full range of, of RPM and load on the left wheel, right? So we can go through the full RPM range and see what the load is on that left wheel throughout the full, you know, with the full RPM range. And this one is another one where we do actually have the some of the code. So I can't go through it a little bit, but we are again missing some data. So this just generates a plot. These are just list plots. It goes through the data and, and plots each data point. This one we construct first our RPM plot. So oops. So here's our first plot, which is our RPM or we name it as velocity here. We can then construct a second plot of where we use this helper function. We smoothed ND where we put the. We find the differences of our data. So that is the difference between each data point and inside a big list. And we run that through a mean filter right with the threshold of some integer. And then we run our data through that. We're on our RPM data through this mean filter of differences to get a. We're basically working out the, the, the acceleration or the derivative but doing it numerically in a really roundabout way. So that will give us now our acceleration. And then we can again go through, plot our acceleration and also our throttle response inside a mean filter and plot that on top so we can get an idea of how that corresponds to acceleration as the general idea with the code. We can also just show this quickly of we grab our load data here and plot it using list plot. And the second plot is this wavelet scalogram. So we first run our data through a continuous wavelet transform. And again, I wouldn't have to write this. This was built in. It does the continuous wavelet transform on our load data. And then wavelet scalogram can recognize that data, recognize how to plot it. We give it a plot label that is just the name of our data from our data set and some theming options. And here's our spectrogram or scalogram, I guess in this case and this one we actually have the code as well, where again we're filtering some data. So here's our RPM data and our load data and we're transposing these lists. We kind of changing the structure of the, of the join list and then plotting them together. Right. So we're plotting RPM against load and that's. That's it. So let's move on to the next example. No questions. So let's go on. So, yeah, let's see. Now we're going to use computation to inject a new viewpoint and a lot of these titles are kind of general ideas and it makes more sense once we start working through it. So this one is one where it looks like we don't have the code. So it's one where I'll just have to talk through. So here's our data. It's just some financial data of, I'll be honest, not a finance guy. I think these are company names and I think these are actually. Are these currency names or company names? I think this is buying against this other thing and its value, I'm guessing. But anyway, some general finance data which we can visualize. We can take this whole data which is right now just a bunch of numbers which we can see have the same column, is the same column and rows. So we can actually visualize it inside this, this kind of matrix where we can change our correlation, we can change some threshold to see how that affects the data. This doesn't really give us any sort of, you know, too great of an insight inside into our data, but putting all of our using our data to construct these graph communities does. Right. So the visualization alone was not really useful. Right. This doesn't mean a lot to many people. However these graph communities do. And what this is is it will, it kind of goes through and figures out how the data fits together and groups it kind of, it, it is in general extracts features and, and, and, and groups using features. So now we've got companies that are grouped together in these communities and, and, and that was because of, of whatever metric that they share. Right. So these are groups that, that were extracted with features that we didn't know about but kind of the, the algorithm was able to pick out in a way and group together and we could also hover over and, and see what which company is which from this and see if I can. And again this, this code is not here but this is a one line thing. This is a, another built in function that you give the data to any. And it just kind of goes off and does this for you which is the great thing with all of this. So this one is a cool example. This is probably my favorite one of the day which is involves some machine learning stuff. So now we're going to use, we're going to get some insights from our data. We're going to extract physical, you know, observables from our data. Right. So and, and we're going to do more computation with it. So the general idea here we have this incoming noise of a car beeping his horn, coming, moving towards us. And due to the Doppler effect you get a modulation in the frequency. So the frequency is modulated as they move towards us. So the frequency is modulated up when they're moving towards us and is modulated down as they move away from us. Right. So that is the general idea of the sound effect which should play for everyone hopefully. But it is, if it didn't play it is just a car doing the stereotypical, you know, coming towards and moving away from you thing. And what we want to do is we want to use that, we want to use just the sound and just our knowledge of, of Doppler shifting to extract our physical observables. Right. Or our insights what we call here. So first, first of all we're going to use our neural network to estimate pitch. So it's going to go through and use a neural network to add every point of our sound, try and deduce what the pitch is, what the pitch of the sound is. And this is called creep or con is. This is done with a method called creep, which is called, which is convolutional representation for pitch estimation. It's just a, A neural is a machine learning method for kind of extracting pitch from a, from noise data. Right. So we're going to use that to get our pitch data and then we're going to build a Doppler model. So we know how Doppler shift in weights, we know the Doppler equations. So we're going to use those to build a model of our shift. And then from that model we can then solve those equations and get our insights which in this case we can get the sound of the frequency. And mainly the more impressive part is the velocity of the car. So how fast was the car going towards you? And you can pick that out just from the noise. So we can show the code here. The code is below in this case. So we'll walk through it. But yeah, this assumes, for example, if we go back to the frequency, temperature is a factor in this. So you know, we have to assume a temperature of 15 degrees C in this case. But let's actually walk through the code. So here's our sound again. It is natively supported inside Mathematica to import sounds and we get these kind of sound players. I could copy and paste a sound or import a sound from my disc. In this case it is just added in line. We can produce a spectrogram of our sound just to see what that looks like. Here's a spectrogram. And here we're going to go through. We're going to use our pitch recognize method, our pitch recognize function with the method creep that we discussed earlier. So that's going to go through our sound, go through each point and try and recognize the p, the, the pitch and put that in a big list. This is going to delete missing. So any pictures that this method doesn't recognize and puts down a missing value instead we want to delete them so it doesn't throw off our data. So delete those and then we. Because this is going to give out those pictures in, in a quantity form. So quantities are this rich format. That is, this is not just the string of 1 hertz, right? This is a unit of Hertz and Mathematica understands what that means. And if I try to add a different unit to it, it would kind of know whether it can do that or can't, or if it can, how to convert between units and stuff, right? But we don't need that in this case. We want just numbers. So we, we're gonna use quantity, magnitude to go through and just make sure everything is just a number, right? We don't want quantities in this case. And then we're going to use this data. So we're going to use all this frequency data that we just produced here and we're going to apply it just to see what that looks like. So here we go. We, we get out a time series. So we get a time series of, of, of, you know, across the, across the time period of our video. We get a bunch of points of the frequency at that time. And let's plot that. We already see kind of general plot of it here, but we can see a larger version of that, right? So here's our frequency data. So now let's build our model. Let's build our Doppler model. So here are equations. So here's the equation for relative velocity and here's the del of this equation. So the partial differential, the partial differential in terms of t of this equation. And again, notice typeset maths, right? We're using, you know, mathematical equations in a way that a mathematician can read. This is not just readable to a programmer. And again, here's our Doppler shift equation that we define. And while we're here, I might as well talk about the convention for defining functions. Square brackets to define our argument pattern. So name of function, square brackets to show it the pattern of arguments that it can take. So in this case it can take an argument of V, it can take an argument of d of t, 0 of t, right? This single line is a blank and that means there is a singular argument of V that is required double line, double blank is a sequence blank, which means there are multiple things called V in this place argument and they are separated by commas. But again it is required and three blanks it is blank sequence optional. I think it is the name. And this means it can be one, one argument, multiple arguments of V or no argument. It can also be nothing. But it's a general idea of defining these functions that we define are the pattern of arguments that they take and then how they use these arguments, right? So the actual method of what they do. So let us define these and we can use them with with some data. So we can. Here we are building our sound model. So the model for our, for how the, for our sound in this kind of situation. So we're giving it our equation. So relative velocity in. In place of velocity for our Doppler shift, right? V0 is just zero because we're going to start at rest and then C being the sound, the speed of sound that we just can. Mathematica knows about. Mathematica has a data repository. So we can grab that one quantity, one speed of sound. We convert that unit and we convert that into a unit and then back into just a regular number. And then Mathematica can kind of figure that out symbolically substitute in what it needs to substitute in and give us this symbolic equation out, which is our model, that is our sound model. It takes in the frequency and velocity and the time and then we can fit that model. So we can use our data now to fit to that model. So we're going to use this non linear model fit function. We take our frequency data, we give it just the list of frequency data, we give it our equation for our sound model and we give it some parameters. So here we're saying, we're giving it I think a maximum frequency and saying what we're solving for and then we can solve it. Wrong button. And we get this fitted model out. So yeah, this fitted model object that now we've actually fit this model onto our data. So now we've got a fit that we can make use of and we'll just plot it on top of our. Just for now we just plot it on top of our original data just to see how good of a plot it is. So here we are here. The blue line is the model that we've just created and the gray line is the actual raw data that we created it from. And again, this fitted model object has a best fit parameter that we just passed to plot, right? So, so it's pretty easy to kind of plot that stuff and it's kind of built in and we can finally extract some other things from the third model, right? So it is not just the best fit. We can also grab the parameters of that best fit, which finally gives us parameters for, you know, speed, estimated speed and estimated starting time and the distance from the observer and frequency. So this just. We def. We hard defined the frequency. We said the frequency is limited to 350. Okay, see, no questions. All right, let's keep moving. But yeah, this example I do enjoy. I'm a physics guy at heart. So this one is My favorite other day. But yeah, we're getting to the actual questions. Bit of why. So even, even after everything I showed here, most data science tends to just be counting things. Most data science, it just tends to be I'm going to go through this data, we're going to count how many of this thing there are in it or how many occurrences of thing, maybe bin them, maybe do some stats. But it, but like we showed, it doesn't have to be that way, right? So it's, it's hard like, like that question we had earlier is hard to know what's possible often from the data. So back to the London traffic example, someone asked can I use this raw data to know the reason of the, of why an intersection has more accidents than another? And that is where the problem comes in that it is, it is difficult to know what kind of insights you can extract from your data without. The only thing you do know is that you can count them. The only thing you know for sure is that I can count all these things and I can correlate things. But it's very hard to know what insights you can actually get and what kind of, you know, it takes, it takes, it definitely takes practice to, to be able to just at a glance see the computation that you need to do to your data to get the insight that you want. Right. So we've got more examples of doing that, of just making computation easier, of getting you to the place you need to be quicker and in a more painless way. And this stuff is going to use our machine learning stuff. And, and look at this, we've got four lines, right? Four lines. And we're going to do something kind of what would be quite impressive in any other language and would take a lot more than four lines. So let's do it, let's grab some, some example data. So this example data function built into Mathematica, it is used, it just knows about a bunch of different example data that it has that you can use for maybe training machine learning models or you know, we're just using as examples. So in this case we've got our data from Titanic, machine learning data from Titanic and we want, we want the raw data of that that is going to give us out a, a list of all the data. So here's the structure of our, of our data. It is a list of key value pairs of the key being a list of identifiers. So who was this person that were f. They were in first class, that were aged 29 and they were female and the outcome they survived. This person was first class was weirdly a fraction age. That, that, that's a strange one. I never noticed that before. So this male was 0.9 years old, but survived. This female was 2 years old and died. So that is the general idea. We get all the, all the Titanic passenger data and, and the outcome of each passenger. So their identifiers and whether they survived or not. So what can we do with this data? Well, we can use it to create a classifier. And how are we going to do that? Well, we don't even have to format this data literally as it is in this list of key value pairs. I can give it to classify. Here we go. Classify. We give it our Titanic data and classify will figure out. Okay, so you want to go, you want to input. Your input is this key and your output is this value. I already know what you want. You want me to, you want a classifier where you can put in these values and you get out what the outcome is. That is what exactly what we did. We created this classifier function here that we can use now with new data. So we can say, all right, what about. Let's, let's, let's guess. Let's make, let's make an estimate using our model. A first class male aged 46. Do they survive or do they die? What are the chances? Okay, they, they, they died. Right. We can also extract probability from this. So we don't, we do, we don't just get out of that. I think I can do probability. I can do that. No, actually we'll show that after. So we can also extract probability from this. Like so. So. Yeah, sorry, I just needed to be in a list. Yeah. So we can also get the probability that the first male died. So it's not. He. 100 died is 70 cents. This model that we built is 70% certain that, that this male would have died. Someone says the 0.9666 age is an 11 month old baby. Yeah, that, that makes, that makes sense. Fractional ages are always a weird one to see. But yeah, I think there are infants that are included in that data set. Yeah. So we can grab these probabilities as well and we can also plot those. So we can go through and, and plot the probability of, of death for a male throughout their age range. So we can see how age affects the, the, the probabilities of survival of death for a male. So we can see actually there is a pretty linear relationship with the younger you weigh, the better your chances were as a male to survive. And the Older you were, the more likely you were to die. So someone says, is there an option for intersection type? And if a crosswalk was used, I think if you're referring to the methods used for the classifier, yes, you can customize these. Obviously in this case we did the simplest example of hey, here's my data, figure it out for me. And it did that on its own. It decided its own method, so use gradient boosted trees here and picked out his own input type, decided that on its own. But we can hard code that stuff in and give it options of specific methods and specific kind of settings to use and, and what kind of decision tree to use and so on. But let's move on to the next example which is an image classifier example. Again, we're going to use the same function, our classify function. And this is here just so you can get an idea that classify is agnostic to your data. Classify doesn't care if your data is strings, it doesn't care if your data is images, it doesn't care. It doesn't care if your data is lists, it just doesn't care. All it cares is it sees a general structure of input output. It wants to know what the expected input and expected output is. That's it. And then it will kind of build a classifier from that and it can even take that in like a lot of different forms. So it can be all together in one list in these key value pairs, it can be in separate lists. So we can have one list of all our keys, one list of all our. So one list of all our examples, one of all our classes or one of all our inputs, one of all outputs. Or we can have these multiple outputs for we can have this flipped format. We can do it as a list or an association. So the idea is you can, your data is classified, is very agnostic to the form of data. Right. So as long as it's in this general form of general input, general output or expected input, expected output classifier will figure it out. So in this case we're going to do images and whether it's nine day, here's our training set. It's a pretty small training set, but it's just to get an idea. And it's just different images of different places are either nighttime or daytime and they're also labeled with whether they are nighttime or daytime. And again we just give this list to classify and it will go through and train a model. Again, we're letting it decide method on its own. In this case, it used a logistic Regression as its method instead. So it picks that stuff out on its own in this case. But again, if we wanted to customize, we very much can. And now we can test it so we can give it this list of other images that is not seen before and we can see how it does. So that's day. That one it gets wrong. That one he gets right and these he gets right. So we can see it is good but not perfect as with, you know, most machine learning stuff. So let's continue on. I think we're kind of drawing towards the end of stuff but we want to talk about automation a little bit and just again, more making your life easier. I'm all for laziness and I'm all for the least amount of human work you can do. In my opinion, the better. Right. That's what, that's what computers are for. So we can show a general idea of, you know, using automation to, to again do some data science by. We've got this data set here of. Actually we do not. I forgot that I didn't have the data. So the idea of this, I might even be able to example data. Let's see. Have we got. No. So I'll just walk through it without showing it. So the data set is a data set of dog images, I think so it's dog images and breed. And what this will do is run it through a feature space plot. It will just give feature space plot this function. It will give it a list of a bunch of dog images. Get just dog images, just a list of them. And what it will do, it will go through use machine learning to extract the features of each image and then it will group all those images using those features. So then we can kind of get these groupings of, of. Of dog breed without ever having, without ever having even the, the knowledge that dog breeds exist. Right. The computer doesn't even need to know that dog breeds exist to be able to separate our dogs by picking out these specific features. And I do, I do want to see if I can. I won't come back to this because I do like this example. But yeah, the general idea is that you don't have to have a step of extracting features and a step of plotting this stuff. All you need to do is give your data to feature space plot. That gives you a feature space plot or you can do it manually. You can also do this manually. You can extract features from. So you can say, hey, find me the nearest. Find me the image with the features nearest to this other image. So we build this nearest dog operator or function almost that where we just give it this test dogs. So we can give it any other image of a dog and it will give us from our data set the most similar image of a dog. So that would be really useful if you using, if you're building some kind of search functionality into anything. You can build these kind of fuzzy logic suggestion algorithms or pretty easily. I mean this is again four lines and this is another actually this data can do. So we can actually do this. So this is extracting again using unsupervised learning. So our previous example was an example of unsupervised learning. So just letting the computer kind of pick out its own patterns from the data and then we can observe that and say, okay, it's grouped these things together. What does that mean sort of thing. That's the general idea of it. And we're going to do some more of that for, we're going to do some, some structured learning now for wine quality. And what we want is we want to build a kind of machine learning algorithm that will tell us, it will take a bunch of metrics of a given wine and it will tell us what it thinks its quality is going to be like. And there's a data set for that. So there is a wine quality data set which some people saw and drunk a bunch of wine and rated it for its quality and then tested that wine for, for some physical markers like its acidity. It's, you know, citric acid content is residual sugars, chlorides, you know, sulfur dioxide content, all of that stuff, you know, ph density, so all its physical metrics and also a, a rating of its kind of quality or bits of how good it is. Right. So we're going to use this data, we're going to use this day to, to again create this predictor class, create this predictor function that will take now a different wine of unknown, unknown physical metrics and give us an estimate. So here we can get an example of data. So here's a kind of statistic summary. So we're getting a stat summary of all our data again by just running this one line. So our count for our data count the mean of the data for the wine quality, the standard deviation for wine quality, the minimum, median, maximum and so on. And this is a resource function. So good place for me to mention what resource functions and this resource data is. So with all the built in functions that Mathematica has, I think like thousands, there's more. So aside from that, there's also the resource function Repository which, these are user generated functions which get, which get. Let's bring it here. Which get submitted for, for review and that our team kind of reviews them and submits them to this repository if they are approved. And they are functions that expand the, the, the functionality of Mathematica even more. Right. So if you can't find a function in the, in the standard Wolfram language documentation, this is a good place to look because someone very likely made what you're looking for already for some, for something that they were using it for. So this is the Wolfram function repository, this is for functions. And we've got the stain for data, right? So we've got Wolfram resource data where we've got our data repository and this is again a big repository of different types of data that you can natively import into Mathematica and just use. Right? And this is data that is vetted and curated by us and is kept up to date, sourced. Right? You can get sources to all of this data and you know, you don't have to be kind of scouring the web for reliable data and you know, messing around with different sources. We can click on any of these and look at examples of their use and how they come in, where, where the data is from, you know, who created it when, you know, metadata and so on. And even we can download the, the raw data of this. But that's the general idea. And aside from this, there's also, so there's, there's Wolfram data repository, there's Wolfram, there's resource function repository, there is normal NET repository. So we also have this exact idea for different pre trained neural networks that other people have trained. So, so we've got, yeah, different neural networks and then there's also demonstrations project which is different demos, different visualizations that teachers or educators from around the world have put together and are just freely available for everyone. So I just wanted to mention those resources. Someone asks if we gave, if we gave him more training data, do you think the score would change? I feel like that is for the classifier and the answer is 100%. The more trading data the better. So when you're trading these classifiers, you're never going to train a classifier on. I think it was this one. Yeah. So you're never going to train a classifier on like 20 images. There's never really going to be a viable thing to do because it's going to be. This kind of learning is really good at interpolating and extremely bad at extrapolating. So we want to give it as we want to create the widest range of interpolation we can. We want to give it the widest range of, of, of data that we can. So, so we are only interpolating and not extrapolating. Right? So that is the main issue with this. So this image threw it off, I guess it didn't. It doesn't have many close up images. So I can pick out for example, no many close up images with close up subjects. It doesn't have many cloudy images. So this one is cloudy and overcast. So the more examples you give, the better. But with that being said, it's not just about number. If I gave it a hundred thousand examples that are all extremely similar, that doesn't really make it better at any other example other than one similar to that. Right. So it's about creating these wide ranging data sets that you want to teach the machine what you want to teach it, right? You're teaching it is learning and for that you want to give it all the information that it might need. Right. So if it comes to deducing night from day, you want to give it every single image that could possibly like be different about night and day. Because it needs to see that to be able to kind of build its, its internal model. Same with people, right? Is like the more, with more experiences, the more, the more you learn, right? So, so the more, you know, the more data in, the more data out, I guess. But yeah, if we, if we did training with more data, it would definitely do better if that data was suitable and, you know, sanitized. So with everything I've been showing, by the way, all of it can be deployed online. So everything I've showed obviously can run locally on your machine. You can, you can run it, you know, as you, on your desktop, locally on your cpu. There is another thing that you can do which is deploy stuff on the Wolfram cloud. And what the idea is, so in this case we are taking our Wolfram language code, we are putting it out into the cloud and then this cloud notebook can be accessed by a web browser, any web browser that could be you. Or if you, you know, you could open it up to be accessed by anyone or you could ask, you could put a password on it or whatever else. So then now we've got this new environment, this, this Wolfram cloud environment where we can push stuff to, we can change these, these live Wolfram notebooks and we can make changes to them, we can clone them and download them onto our system. And also other people can also, right. We can choose permissions, we can choose whether people can edit or not edit and what they can edit and what they can't edit, right? So we can build these full deployments on the Wolfram Cloud either for having portable functions for ourselves or for distributing these tools. And again, this you can also download, you can host data on the Wolfram Cloud. It doesn't just have to be Wolfram data. You can, you know, you can host Excel files, you can host JSON files, you can host, you know, any sort of data file you can put onto your Wolfram Cloud as well. And that can interface with your programs, right? So that can be accessed within your programs. And with that comes access to APIs. So we can, we don't have to deploy a, we don't have to deploy a notebook. It can be an API. And then now we've just, with a few lines put up this, this REST API that we can access externally, even outside of the Wolfram environment, right? So we can have these, these APIs that can be accessed by any other language which I personally use that when we build React pages. So we build pages using JavaScript and React and all our computation is done with Wolfram language APIs that we just use Axios through JavaScript to interface with, right? So all our computation still Wolfram language. And then we can have our nice React front ends, right? So all of this stuff can live on the Wolfram Cloud. You can navibly put it up there, you can share it, you can host it. There is also enterprise services, so you can host this cloud in inside your own firewall if you're a big enterprise. So the idea is this stuff is not just local, it's not just localized to your system and is very easy to get deployed out and kind of distribute out. And also the Wolfram Cloud, it doesn't just support, like I've been mentioning, there's support for, for a wider range of frameworks and languages. So JavaScript is supported. So you can have, have JavaScript files hosted on there, you can have R files hosted on there.net and, and C, even DLLs you can have on there. So all of that stuff can navy be hosted on the Wolfram Cloud along with all your deployments. So here's an example of this, just a random little app that we built. So here's our bike data from earlier and we're just building, building a, a visualization here that creates the way we can pit a city in the world. And it will show us a visualization of the bikes that are locked up in that city. So it will then download the geodata and then plot all our airpoints on that. So let's give it a lot second. But that is the general idea of our app. We can give it any city and find, see, you know, the distribution of bikes in that city. And now how do we go about deploying that online? Well, it's just one line. We just take this app. So we've, we've actually named this. So our whole app is this variable bike app. Now we just give it to cloud deploy and put it online. That's it. We just, that's it. We give, we give it our app set up permissions. We don't need to default. By default they are public but we can just change them if we'd like. So permissions public. And we can also change our cloud object URL type which again usually you can leave this blank and it will figure it out by default. But in this case because we want to have the, want it to be interactive, we want the environment URL type and if we just run this line it will just boom, put it up. Here we go. Here's a link that now if we open and if I log in first, let me just log in. Here we go. So we have this link where if I open it, Logging in is taking a little minute. There we go, There we go. And then we get this link that we can go directly to and use this, this online tool where we can choose a city to, to display. Now it is useful to, to know anything that, that anything that you build like this is going to be more responsive in, in your, on your desktop. Right? Stuff in the cloud is obviously going to start being a little bit less responsive. Some stuff is going to be a little bit less smooth. So, so yeah, keep that in mind that the cloud might need certain workarounds sometimes, especially with things that are very slow. So someone in the chat talked about the problem with the data sets. So the London accident. So yeah, none of the data I was sent out with the notebook, I'll have to send out all the kind of source, all the MX files and send them out individually after, after the talk. But yeah, any, if you see any lines in this talk, if you're going through yourself that say get something something M. Get something something Wl. Those lines are not going to work and everything after it won't until I send you that data. Once I send you that data, you can just put it in the same file in the same folder, the same directory as the notebook and then everything should just work. Yeah. Here's our final thing. Now we talk about APIs. So let's deploy one. We'll use our Titanic classifier from earlier. So if we want to build, if we want to build that into an API where we can put out this API, call this API call of a Titanic passenger, and get an idea of if they survived or didn't. So here, here's the API that we put up. If we go to it, obviously we get a failure because we didn't provide any input, any input to the fields. We can do that in the standard way. So we can do class equals first, we can do age equals 20, and we can also do sex equals male. And if we run that, it will just output this string. It is now it is just configured to output the string of, of the outcome. So died. But this is not very useful. This is not how you'd use an API. You'd use an API by interfacing within it, by interfacing with it. And we can show that by doing URL execute of this link. So we can. So I'm going to do percentage sign 54. And this just means output 24, output 54. Right. So this just means take this output this card object. So I want to, I want to URL execute and I want to do my class first. My age of. Oh, of 20. And oops. And my sex of male. Oh, let's do female this time. So here we go, we can get an output for that. So where did that go? There we go. So we can get an output of that. Why does that delete everything? Okay, let's leave that there. Yeah. The general idea of these APIs is that you interface with them in any standard language. So obviously I just showed it in the Wolfram language, but we can do this in JavaScript using Axios. We can do this inside Python, we can do this inside C. Right? Any, any language that, that can make an API call can interface with these APIs. Right? So now we've got this, this deployed API. And technically any of you could also interface with this API because this is public. So if you run this link and do an API call to that link using the correct fields, it will work. You'll just get a prediction for survival. But that's kind of, we kind of go into the, to the end of stuff. And that is generally the end of me. But, but the general idea of the talk was don't restrict yourself to these like, okay, I'm gonna go through my data now. I'm Gonna, I'm gonna, I'm gonna get all my counts. I'm gonna. Okay, I'm gonna get my standard correlations and my standard metrics. There is a lot more to be done on the computation side. And, and with that, I think that's where Mathematica shines because the whole tool set is huge and it is in just the same place, right? So the same place I do my stats and data science, I do my visualizations and I do my, you know, every, everything else. All my data comes from the same place, all my functions. When everything's the same place, it kind of makes that, that workflow a lot easier. So there's a good question I want to answer before I end. Someone asked about PowerShell. Where did it go? So is it possible to call a PowerShell command script from the Wolfram language? Yes, it is. And it's not just, not just PowerShell command external languages. You can call entire external languages. Let's just. Because I get excited about this, I like it. Let's talk about it a little bit before I end. So external evaluate is what the function is. And this external evaluate will interface with your system and it will let you run in. In kernels from other languages. So for example, we can start here a Python session where we evaluate 2 +2 inside Python. We can start a Node JS session here and we do a math square root of 36 and we run these, these lines, right? So yes, you can use external evaluate using. You can do shell like this and that will run whatever you write here through the PowerShell or through the command prompt. PowerShell you can just do PowerShell like so. And there is also, if you don't just want to do a single line or script, you can do zits start process. You can do start process and pass it to an executable that will start the executable. In this case it will start a system shell. System shell in this case is cmd but we can Change it to PowerShell and then we'll have this process variable inside Wolfram language the that we can use to write lines and read lines from right? So I can then take this process, this command process, this command line process and say right line for example line from that. So we'll actually run this. Let's actually show this. So here I get this process object of commando exe. Here's my. The PID for that, bunch of other information for it. Now I can use it so I can write line right to this process echo example line and it will just do that but notice that I didn't actually get any output. And the reason is that's all contained within the stream of the process. So to do that we need to read string. So I want to read string till the end of buffer. And if we do that it will give the whole terminal and here's our actual output here, echo example line and then it runs that and gives us the example line and we can get the status of it. We can write other lines. So we can write exit for example to close the process. So if we run this, the last line is now exit and then we can check again for finished. Right, so that's the general idea. You can do this with PowerShell, you can do this with CMD, you can use the external evaluate to do other languages like Python, like Ruby, like J, like JavaScript and you can do as well. There is a specific type of notebook cell. Let's see if I can put one here. There it is. So an external evaluate cell. If you do greater than symbol or this symbol is it. Is that greater than or less than? I guess it depends. But if you do greater than symbol or less than symbol, this, this right pointing arrow on an empty cell, you'll get this, this, this type of external evaluate cell and what this will do. You can choose here, your external language. So you can do an SQL SQL query or a Ruby. You can write some Ruby code or some R code and so on. So yeah, good question. Thank you for asking that. That is stuff that I make use of all the time and that is, that is what we use. So we, when we do our REACT stuff going back to that we build. So instead of doing NPM build on command line, we've built all those tools inside Wolfram language where we've got functions that kind of create our React project for us. They go through and edit those projects and put them in a, in a kind of in a different template and everything. So yeah, you know, you can very much interface down to the lowest level of your system using the Wolfram language. It is marketed as a, as a high level language and it is a higher level language, but you can definitely. There's some low level stuff you can do with it for sure, but that's kind of everything unless there's any more questions. Oh, and as for can it be deployed via web browser, sadly that part of it no. So all of this external evaluate stuff is local to you. The only, the closest thing you can get to that is you can write a JavaScript application and host that on the Wolfram Cloud, that's the closest you can come to it. Sadly, when you're online, technically the Wolfram cloud, you're on a. Basically you're on a Linux server running, running the Wolfram language. And a lot of these functionalities are kind of blocked from the, from the Wolfram cloud because it's kind of, you know, when are you running the session of SQL right where you're not you. Because we're not creating local machinists, we're not creating machine instances for each online warframe cloud session. We're actually creating. They're not sessions, they're just individual kernels that you're accessing. So you could in theory have two people accessing the same SQL session at the same time, which would be a problem. So that's why external evaluate stuff just doesn't work in the cloud at all. But you can do some cloud stuff using JavaScript if you want to use a different language. So you can't host files of different languages on the, on the Wolfram cloud. It doesn't have to be Wolfram language. But before we end, there is, there is a. I just want to mention our next. So I think I'm giving this one as well. So we're doing a custom neural networks webinar. When is that? I think it's later this week, but there is a link on here that you can click. So it is on the 28th of November. Sorry, I just had to look at the date. So, yeah, if you want to join that, that is going to cover kind of more. So instead of using Classify with this standard stuff, we're going to go in layer by layer and build neural networks using specific layers. We want to build custom neural networks for work that is novel and new and we're going to do that by talking about different types of layers and how we can use them in the Wolfram language. But yeah, that is everything for me. Thank you everyone for joining. I hope you've enjoyed the talk and let me just check through. I've not missed anything and if not, yeah, I think that's everything. So, yeah, thank you everyone and I hope to see you at the, at the custom neural network talk.