Deep Learning and Scala

SF Scala: Oswald Campesato, Deep Learning, TensorFlow, and Spark

Recording: SF Scala: Oswald Campesato, Deep Learning, TensorFlow, and Spark

[Music] so hi everybody it's good to be here and I'll be your tour guide for maybe an hour to show you some of the concepts of deep learning I would strongly recommend that you use this approach rather than tryna turn the api's first that was a complete waste of time for me I thought I was being clever yeah too much so the when you see these concepts the api's are just the implementation of the concepts obviously so just for the show hands how many people are basically brand new to deep learning okay how many people have seen my previous presentations you have okay everybody else I'm gonna tell the same lame joke so sorry and so what I I'm gonna put this look at this so here's the thing the slides are gonna be online this is it luxury in a presentation that's more than an hour I'm going to give you the 30 minute version so I'm gonna be skipping stuff but pointing out two things and everything will be online so that you'd be able to see it later on when you have time and so just a kind of a high-level summary if you will of some of the topics that I'm gonna talk about they come in clusters so usually when you talk about one thing there's three or four of the things that are associated with it there's no clear separation so there's not so much linear is more these are the things that I'll go over and you see in there I have more hyper parameters because the ones before them are hyper parameters I'll tell you in a few minutes what those are real quick this is sort of the overview of different technologies need to know them to do deep learning and make a couple of Jennifer Sanne red-dot parts of that a couple of things one the machine I can't see here data science does overlap with which deep learning you can do tensor flow and caris through our in our studios so if you wanted there's also something called reinforcement learning which is those games the system's you heard they play the game a billion times against themselves okay technically not part of deep learning they're in there somewhere with machine learning somewhere in the side there's also deep reports on learning so just so you know this first year was last year so there's home development stuff home automation then there's deep learning and then there's machine learning that was from last year let's see what they do next year this is the first official event summer of 1956 the fifties pretty much were when things were starting to get formalized in some sort of way the fog was clearing and these are the people who started it and even says there at the beginning one of them is John McCarthy the inventor of Lisp another one is Claude Shannon who started information theory Marvin Minsky one of the Giants from MIT so one of the things they said which I kind of liked they thought I'd have it all figured out by the end of the summer I love that optimism so just to go into a little bit more detail I'm going to go back here you see the three circles on the upper right traditional AI is about really rules and conditional logic and some data and that led to believe it or not some very powerful expert systems in the 70s and 80s and some of them still exist in fact Google Translate used to use that until they got them to deep learning whereas on the other hand machine learning deep learning lots of data lots of index as a compute power lots of algorithms and of course for deep learning the neural networks so this is the thing I'm going to talk about a little bit longer it's kind of this cold mess of stuff when you look at it is I know when I first saw it I got kind of scared like what what am I supposed to do with this as you can see there's a layer on the left that's the input and these things called hidden layers and then the output what does that mean the stuff on the left you provide a vector of numbers and they get propagated through these hidden layers which of course require having numbers in there as well which aren't labeled and then at the end something comes out so you might be asking how do you figure out how many hidden layers do I choose that's not obvious because it's a hyper parameter that's something that you set before you do the learning process the number of nodes I say nodes I mean neurons the number of nodes pretty hyper parameter the initial values for that neural network hyper parameters so you'll be some more that I'll talk about in a few minutes so let's start by using one technique for initializing it with random numbers from a Gaussian distribution n 0 1 then we'll start with just whatever the the hidden layers are in there which are just essentially intermediate computational layers to do the learning stuff and the goal is to find the set of values for the weights in the edges in order to get a good approximation for the data that you have good meaning subjective and we'll get into more of that in a minute now you notice that the right end of the four nodes I know automatically this is a classifier a classifier means is it a bird dog catfish is it spam or no spam is that the stock going to go up or is it gonna go down is it fraud or not in the case of two it's a binary classifier so there's a class of algorithms that are classifiers there's another class that's called regression for regression that means there's only one output node so for example for stock you wouldn't say is it gonna go up or down you're gonna say how much will it be you're treating it as a continuous set of values not the mathematical sense because values for stock there's their gaps but it's almost as though it was continuous there's also a meanest is another data set with the digits ten digits so there would be ten output nodes over there let's take a look at and I didn't draw it in I don't have a slide for this let's take a look at an example where is housing how many features are there how many attributes are there for a house so there's an square feet number of bedrooms bathrooms blah blah blah so try to visualize an Excel spreadsheet where you have each row is data for a particular house the numbers are the values for the bedrooms and the square footage and all the rest and a rightmost end it's going to be the value of the house here's how it works you choose your framework you supply this data it's going to come in on the left end and it's all those numbers associated with the features not the rightmost number that's the cost of the house what happens is you pass in those numbers does this computations and then the result which we're pretending is only one node is compared with the number that's in the spreadsheet the numbers are different because we randomized the initial values so we end up getting this thing called a error function which is a hyper parameter and it's based on these attributes that you've got in there and it's going to figure out how to calculate a number which is based on derivatives partial derivatives chain rule in order to go from the right end backward to update the weights so when you go from left to right for propagation from right to left backward error propagation and one of the other things that's in there I'll throw in is called the learning rate which is a hyper parameter yeah usually between zero and one so what happens is in the code you'll have two lines of code generally where you'll have initially there will be cost function equals something it's in the framework and then there will be this gradient descent choice hyper parameter and then there's the chamber chaining method chaining so there's that da LR learning rate you set it to a number dot minimize and then there will be the cost function that you had on the line before those two lines come together very often those are the three things you need for backward error propagation in order to calculate the new values to update the weights how many times did you that depends on the data set something like amnesty thousand training images that's what epoch you usually do something let's say 20 that means 1.2 million times a forward and backward forward and back each time updating all these numbers and then you have finished with that and you got 95 percent accuracy is that good maybe you take the test data which is separate you don't modify the weights in the model it's locked down and used to the forward pass and then you figure out what the percentages of accuracy then you compare with the training if the numbers are close it's probably good model if it's not if it's lower you probably have something called overfitting which is like signal and then there's noise and a significant part of the noise is treated as though as part of the signal that's the general idea and there are techniques to deal with that dropout rate and so on and so forth that makes sense that's sort of it kind of the rest is just details so let's take a look at a simple example I said the will do the housing well that's a regression because you'll have a data set and then there'll be some number you go let's predict what the cost is going to be for some house does anyone remember slope equation of the line y equals MX plus B is back to haunt you if you didn't like it when you were in high school so M is the slope B is the y-intercept what that means is something like this you change B it's a vertical translation you change the edits of rotation they're two independent variables so you're trying to say what's the best fitting line for that data there are lots of data sets out there that don't fit linearly we're gonna completely ignore all that stuff because we can and we're gonna use the simple ideal case the idea is to get the line that's the closest to all those points and what does that mean one way is to compute the minimal minimum squared error and the way that works is you see each of those black dots you take the distance vertically from that dot from where would be from the dot were on the line square it nothing's negative add them up divide by the number of points that's the thing to minimize it's quadratic it's got two variables m and b in the horizontal plane so the cost is going to be in a third dimension this will look like this this is called a convex surface and what that means that you'll either have a maximum or minimum in this case is the minimum that point at the bottom has a value of M and B that's the best fitting line that's how you equate the two you actually quantify it so now this takes two planes perpendicular to the horizontal plane primitive the axes they will intersect in two parabolas that intersect on that bottom point why do we do that because when you have a parabola you can take the partial derivative with respect to that variable set that derivative zero that's the venom who remembers differentiation sorry okay well for the convex surface it is that's why it works there are other cases which you'll describe so we can solve would get equation closed form it's all done great know it in life it doesn't work that simply let's pretend that we didn't know this and we had some random value for MMB it's gonna be on this surface somewhere generally what's gonna happen how will that dot let's say it's a little tiny sphere if we were to release it what's it gonna do it's gonna you know a little time slow slice it's gonna go in the direction toward that bottom point that's gradient descent keep that in mind it's gonna come up again so as I mentioned before in a house with the same number of square feet very coarse-grained system you're not gonna get a very good it's gonna be under fitting actually the opposite problem let's add some more features I've got six actually saw dataset that had 30 now here's how the equations generalized instead of the y equals MX plus B line we get a hyperplane still linear then we come back to this guy so the numbers on the left although or sorry the input the values the input layer we're gonna take those row of numbers 15 30 however many there are and propagate across it's been initialized there's one important thing that I didn't tell you this is linear which means you can multiply all the matrices together between the consecutive layers get one matrix collapse it down to input and output which defeats the purpose of the networks so what we need to do is add non-linearity which is accomplished by selecting something called an activation function which is a hyper parameter so by analogy think of driving on the highway there's no cars around you can drive at a constant speed if you're in a parking lot with speed bumps you have to slow down and speed up and slow down all that so the analogy is simply being it breaks up that constant behavior where you can drive all at the same speed that's kind of the idea if he's confusing us okay bugged me for a long time until finally just became clear after seeing it 20 times so what happens is you have the input values multiplied by the matrix give a new vector and pass each of those numbers through that activation function and get a new vector and repeat that's the extra twist does that make sense sort of kind of okay so these are some of the equations who can kind of skip through this a little bit the matrices yeah this and that Oilers function you remember anyone remember Euler's constant remember log L og base 10 and then there was the Ln base e that's the number and it turns out it's the only nonzero differentiable function that he goes its own derivative in the plane just as a bit of trivia it's got a lot of other interesting properties this is the sigmoid function activation function between zero and one you'll read stuff about squashing the values take any set of numbers positive negative regardless of how big their pass them through that they'll all be b201 so you're squashing it here's another one 10 H or fan hyperbolic tangent that's between negative 1 and 1 look at this one rectified linear unit all these are available in all the frameworks there's rail u6 which cuts off at 6 that's specific to tensorflow and so these are the functions that you can use there's something right now this is the one that's popular there are other ones as well we don't need to worry about that this is this exponentiating the values again it'll do the same thing you'll get a set of numbers between 0 1 whose sum is 1 is used for convolutional neural networks so in Python just if you look at that you see sigmoid that is pretty much the formula that you saw before look at 10 age it's actually called tan h conveniently and r lu is the maximum of 0 that number fine by the way at that point to zero is continuous but not differentiable mind your little detail there so some of the depending on at what point in time that you were looking at activation functions different ones were in vogue I already mentioned that rail U is the one de jour however for recurrent neural networks and LST M's actually specifically they still use sigmoid and 10h so don't throw away that knowledge it's not wasted it's definitely very useful going back to cross functions here we already saw this here's another one this one's a bit problematic why because there's that point there where one way it's a minimum the other way it's a maximum and there are techniques for getting away from that point to try to get to the minimum and sometimes it's just well I'm not at the minimum absolutely I'm at a relative minimum but it's good enough that's another compromise it depends on the problem you're working with in deep learning it's a lot about heuristics in approximation and good enough and slow enough fast enough whatever so it's very much data specific data dependent I should say this is a cross entropy related one you can check out the stuff that I mentioned on Wikipedia there's lots of good entries there actually and selecting a cross function not so important CNN's vers Ernest what time is it by the way oh good I'm sort of a new schedule so convolution neural networks about 60% of the neural networks are CN NS as of last year probably still pretty much this the case as well there are some things that you can do image processing you can also do audio as well RNA is recurrent neural networks have some issues it's a cluster of different types of neural networks the darling of the our LST M's long short-term memory we won't have enough time tonight but those are the things where you do something like John lived in France John traveled in Europe John speaks French if you started with John speaks blank there's no way of knowing it beats a basically random choice so Arielle STM's enable you to do that sort of stuff and then work reasonably well so cnn's here's the idea we have an image and you scan it with a filter and the filters built into the application that the framework you don't have to worry about what's in there is generally a three by three matrix and you might pick say sixteen of them and each one of those ones scans across it computes an inner product and the number and generates a feature map why are they doing this apparently our our eyes work like that there are parts of our eye that could detect vertical segments may be horizontal ellipses that's what has been based on that idea and it does work except what it fails spectacularly that's another story which we won't get to tonight or less so you get these feature maps and then this is how it works as an example see the one in the middle where they got the one at some point as you're scanning across you're gonna get to the one on the left with the green so it's the one x 42 and you get it at 42 there does that make sense so you're sort of it's like the tricorder thing you know skin and across the body I want to pick up what's what's happening in here and you do all these different filters that each one gets a picture of something and as an example here are the filters to sharpen an image to do a blur edge detect emboss these are in Photoshop and all the rest this is it there's no rocket science involved so what happens then after you got the feature map it's it's kind of like an image but it's more like a heat map and what you have to do is make sure that the bag numbers are replaced with zeros hence rail you so convolution layer then rail you then this max pooling so you take two by two typically pick out the biggest one and then you get the thing on the right so you end up throwing away 75% of the data however by analogy compression algorithms there's lossless and there's loss see what's JPEG lossy it's the works however yet another caveat put a big asterisk next to this Geoffrey Hinton since 2011 has been working on an alternative off and on call capsule networks which have advantages they don't throw as much data they do some better things they give you better ability to look at superimposed images it still uses the convolutional layer part but it doesn't do max pooling and if I can quote Geoffrey Hinton the godfather of deep learning he said something like the success of max pooling has been a disaster for convolutional neural networks obviously it bothers him a lot and he's come up with his other technique it's more complicated but it helps with things like adversarial networks the things that you can use to fool systems that try to figure out what's in an image self-driving cars they use CN NS so that's obviously important here's an example this thing who's worked with Karis good o for though you already know this so look what we have here model importing sequential that's just a container for layers for a neural network look what we have down below dense that means it's fully can it drop out I mentioned that all flat and activation come to D max pooling Anna Delta that's a particular optimization to the one that I was mentioning there were hyper parameter for greeting descent look what happens input shape it says there's three images of three by 32 by 32 the three is our G and B then number of classes 10 is the M list example you're gonna classify there's an image coming in as one of the 10 what digit is it and then you start the model look what we do add to column 2 D 32 of these 3 by 3 filters padding I didn't talk about that no big deal input shape is up there activation rail you come to the activation mat you already know what it's doing that's why oops some people really like Karis because it's a lot more intuitive and sorry about that the best part how's that oh can you hear me no no yes I told you was the hardest part yes good thing can you hear me no good good thing it's not surgery so tensorflow you know all about it you've heard about it four times as many stars is the next closest one and you know trade offs it it's lower level you don't have that facility that you saw they're adding more of it but it's still more to the to the metal I guess you could say so it has support for these different languages and devices a CPU GPU and so forth you've probably already seen that you visualize stuff with tencel I can't show you tensorflow because I was doing some updates last night it was late and I host my system so I have to reinstall a ton of stuff serves me right but it gives you a graph and then you can see the error decreasing and the accuracy it's not a stuff you can do a lot of good visualization it's one of the unique things about tensorflow that isn't available in some of the other ones here's the usual suspects for use cases pretty much what you expect it can do it now some of the aspects of it it has to do with these things called tensors which are multi-dimensional arrays and it creates a graph so you have nodes and you have these tensors you have operations and it's all deferred which is trade-offs there's actually eager execution introduced and wound up for part of the main line from 1.7 it looks more Python tasks which they're doing with other things to decrease the impedance mismatch so you don't have to go back to Python and tensorflow because if they're crossing boundaries for processes so they're making it more they're making a Python desk inside of tensorflow anyway the is anyone familiar with it I think you are an ast abstract syntax tree you can sort of think of it as a graph in tensorflow is like an AST steroids it's got a whole bunch of stuff that's happening so what you have to do this is a little strange maybe when you first see it you have to you get this session object and you invoke the run method and in the method you specify the thing that you want it to compute not exactly intuitive so I'll show you in a second and you have the dimensionality of the tensor corresponding to different dimensions of something that for example a constant has zero order then this vector matrix 3d usually don't go up higher than 40 I think met a company they're doing five dimensional tensors kind of unusual so here's an example we have there's constants placeholders in variables I won't go to the difference between them it doesn't no big deal for tonight but just as an example to execute something we have a constant we printed TF constant this is the Serta idiom import tensorflow as TF TF is always tensorflow they basically co-opted it and when you print it you to get the metadata you don't get the value that's actually assigned to the meaning the three so here's what you do SAS equals t f dot session prints a star on dot the constant remember which is I just said a minute ago and then it'll give you the value intuitive hardly here's one that saves you aligned with TF dots sss print that still will look at your execution in a minute your similar thematic stuff add subtract or divide it gives you what you expect here's some other stuff we've got PI and approximation what's the sine of PI radians 0 what's the cosine of PI radians negative 1 what about sine of PI over 4 cosine Phi over tangent of PI over 4 tangent of 45 degrees everybody remembers one so let's look at the values oops we said 1 we said negative 1 what about this other number some proximation so just FYI in case you're doing with scientific stuff be careful that or this you want to make sure that is within the acceptable range of precision that's basically it so now look what we have put a B and C what does it see it's the product of a and B a and B haven't been initialized so you can't calculate the value except by using this edict sets a and B and notice at the bottom print assess our run of and we specify the feedback and it computes it does that make sense kind of sorta that's how it works this is what you're in for when you really go in deep dive so now what do we have an example we have W is this it's going to be a one dimensional array X and B look what we have W X this W times X what's Y W X plus B what's that the generalization of y equals MX plus B the line it's the hyperplane this is linear regression in tensorflow that's how you do it that's how the frameworks do it and so then here you see you have the feed dict specifies X the second one X and B because those are the numbers and needs the values of the variables that he needs okay when you want to save a graph in tensorflow i've showed you in red that's what you add to the code then you run tensor board from the command line which I can't do and then did I put it in there yeah tensor board - - log dirt equals and that's the directory where there's gonna be some tensor flow graph stored on the filesystem and then it'll generate you know it'll be in a web page six zero six which if you invert it what is that spell goog just in case you were wondering that's not that came over the number wasn't random eager execution looks more like Python so it's a lot of the functionality intensive photos available here's an example X is 2 dot it's an array so it's one dimensional tensor M is the matte mall X and X print is four so it's more Python desk and it's in the mail in it okay it's either 1.6 or 1.7 and the ladder came out about a week ago so it's fine if that's what you want to do here's some examples I'm not going to go to the detail some of the code samples that's the link for the github repository with this code and there's a link down below for lsdm Center from spark I'm going to show you just the first one linear regression I'm not going to go into a lot of detail because I'm running at a time for one you remember I said that in order to do backward error propagation that you need three things do you remember this okay if you don't it was the gradient descent thing that you choose hyper parameter learning rate the other have another Hydra parameter and then the cost function which they call optimizer so do you see those lines in blue can you see them I can't see where is it I can't oh there's oom okay great oops see those blue lines Matt ball inputs and weights these are the predictions we're predicting stuff loss loss cost the sum of the square of the difference of the predictions and the outputs I've skipped the first part remember what I was saying about summing the squares that's that and then train operator operator you could say TF transfer train atta grad that's the gradient descent math is five or six of them to dot minimize remember I said minimize the cost which is the loss there you have it that's what that means if you can figure that out without ever even seen any of this stuff you're a lot smarter than I am because this is gobbledygook when you don't know what these api's are about does that make sense kind of sorta remember if you're like me after about the 20th time it's becomes oh yeah yeah this is sure makes all sense so just a comment how much time do we have you need 20 minutes 15 minutes okay little sort of sighting yeah I hope so so you know all this stuff of deep learning there's a lot of discussion there's height there's not as much as blockchain but there's all these it real is it fake is it what's the story some success but maybe is a lot of fluff who knows that's not a fair question I want to say one thing about that two things well there's something called the universal approximation theorem has anyone heard of that no one it states that any continuous function in the plane can be arbitrated arbitrary closely by a neural network the differentiable functions are there's lots of them they're a subset of the continuous ones remember rail you that limit it's got the kink in there it's resolved that there's an uncountably infinite number of continuous functions in the plane each of which can be approximated very closely by the neural network which tells you the expressive power of neural networks is immense you may not believe that let me not make much of the difference to you here's another thing that happened last summer a startup created a barcode scanner for blind people and the one before them their product was $1,300 theirs was $20 using deep learning and this all it did was to scan the and you can't expect much for 20 bucks so after a while it turns out that this little barcode scanner started reading the dietary information on the labels you know alike the ingredients and the percentages no one had trained it to do that no one expected it to do that no one knew how could it possibly do that well my answer is simple that's the power of deep learning it's kind of a feel-good story in a way you know and if you got that kind of nihilistic we're all doomed sort of style of movies that you like which I do I can see I can hear the voiceover first it was the barcode scanner for blind people and a month later Stein it and my answer is I'm not worried so other than that what we're gonna do it just on schedule here there's a an example of a docker container with those technologies in there those are the version numbers and Kahn is going to take over and show you some of the things that you can do with that and I think it's interesting so take it away Condon I've got like 15 minutes I think so I don't think I'm gonna be able to cover everything but I wanted to talk a little bit about the Scala API for ten to flow so this was developed by a individual who's a PhD candidate his name is Platanos there's the link for that it's fairly easy to put in your SBT there's a little bit of a hitch because it's dependent on the C API for tensorflow so you either have to custom compile it in basil or there is a jar file that he releases with a snapshot that is specific for OSX or Linux so that's just one of those things you need to be aware of the so the documentation is really limited because it's one guy trying to do all this stuff so he's got the api's for tensors learning and four so tensors are pretty simple and they're very similar to numpy so anybody who has worked in Python you're gonna be pretty familiar with how outer structure of the tensors learn is similar to Kharis so this is it's you know again it tries to mimic Python for a lot of people who are most familiar with that the core level stuff is for the people who really want to dig down deeply so it's it's good but there's not a lot to do this isn't really in my opinion really primetime but it's it's an interesting project and I think it you know it merits some exploration so importing that this is very simple text I mean this is this is how it looks you can probably mistake that for Python of course the advantage of Scala is static typing but inferred right so you can see that that's no problem we're going to explore a multi-layer perceptron for the minced everyone's familiar with that right the the the letters and how to identify X Y Z but not you import pretty straightforward we're just importing that data said downloading it shuffling around in badges so this is where I'd like to borrow from as well slides for a moment and kind of specify something this slide here when he's talking about that this is a fully connected feed-forward network right when we're doing things like convolutional neural networks those are also feed-forward but then actually they're actually not fully connected usually we have this right here the final layer which is fully connected but the rest of them are not and so you're gonna see why we need that reduction and the advantages of that that's pretty much nothing sorry I'm gonna go through this a little quickly so this is kind of the meat of creating the tensors what's important to note is you see here he was talking about activation functions here we're using r lu that is pretty much standard there's something called leaky r lu as well but for CN NS r lu is pretty much it tan H you can still use but I don't think you know sigmoid it's pretty slow I don't think anyone really is gonna use that in a practical way so the layers themselves as you can see here are reducing and this is where all's well touched on max pooling let me get to that let me show you this so what we're really doing here is we're sliding across this image and we're reducing each layer by a certain amount so we're moving this way we're taking this square we're taking another square and it overlaps so that we can preserve dimensionality within those layers eventually what happens is you go here and then this is the where again I said we have fully connected layers and right here usually is where we're using softmax softmax is a function that translates everything to a sum of one so it's easy when you see here the labels of birds sunset dog you're gonna have a percentage and they're all gonna sum to one so the likelihood that it's a dog versus a bird you're gonna see that difference here again is the max pooling so when we take this is the dimensionality reduction where we're taking this and we're just taking them the max from each grid what's interesting about this is so in standard CNN's you see the reduction but when we're doing something like our CNN where its regional CNN actually we reduce and then we go back out so it's kind of it you get a lot of layers that's so we're gonna create that I'm gonna okay again this is something that was touched on but gradient descent for back propagation there's multiple techniques right now I mean standard gradient descent is okay you can play around with decay rates if need be stochastic gradient descent is kind of it's pretty good but one one other feature that they've done is that it's called stochastic gradient descent with binning and what happens there is you actually bend the data and it's actually faster the the technique with stochastic gradient consented a descent is it is actually noisy because it's stochastic so but what's interesting is with binning it's actually faster and more accurate because you're just taking chunks of the data and you get it's highly parallel so that's that's that also helps with the speed mm-hmm for this example though we're actually just using gradient descent a lot of code I want to go back to this for a second and talk about the back propagation you when we're doing that this is where you know I think Oswald mentioned that you're going to see kind of the network's train themselves this is this is where it's very important these these are the technique with stochastic descent gradient descent but what's interesting is that there's a lot of risk of overfitting and typically what you're gonna do with this is you're going to take you're just going to drop 50% of your layers in the network and what's going to happen with that it's gonna force the network to find a different solution to the final layer so with that the the code is pretty much straightforward when it comes to how you're triggering it you have the this is a this is a lazy because this is a dag attention flow 1.7 has the eager execution but this one is still lazy and the Scala I don't think has caught up to that yet so you're not gonna be you're not gonna be able to do that we're going to do some so we can show you can see here we're doing max steps we're doing you know for about a hundred thousand and then going show you here code which sucks you all right a whole lot of code so you can see here that where it's processed at the end instead a lot of data and then we get to the evaluation and training right here as I said we've created all these layers eventually what you get was the softmax is you get that's that recommendation based on you know whether it's a bird or a cat or a dog and the the the backpropagation is not that accurate for this one unfortunately I didn't get the final piece of code running so yeah that's it okay so anyway I guess that's it you guys have any questions for New York where's Oswald busy okay yeah go oh yeah I'm sorry about that you were waiting for that so there are a couple tech there's a couple packages for that one of which is tensor frames have you explored that at all so the yeah so there is the tension flowin spark there's I think tester frames is actually interesting although there hasn't been a lot of development lately on that but it's actually a DSL you know for the scholar language and so and so it allows for a lot of flexibility and you know working you know it's based on protobufs so I think that it's a it's a good solution I think they they stopped developing it really when you know there was a tensor serving and those solutions like that any other questions you see this ten hours Friday night 6:30 - yeah [Music] any questions almost Allegra the site's renovated [Applause]