Very impressive, but it has also some limitations, the softmax output that shows the confidence is often unreliable (tested empirically). This is an example of misclassification that has a score of 99%: https://imgur.com/a/wnr8K
Just to confirm for the facial recognition/ detection, modern DNN algorithms outperform the 'classic' methods that took decades of continuous improvement ...
Yes ONNX support is not mature even for PyTorch --> Caffe2. There are problems with basic things like affine BatchNormalization. But still the situation is a lot better now ... before we had to write our own converters from one framework to another.
It is our framework of choice especially when prototyping and implementing new differentiable programs. Although we use Caffe2 in production right now mainly because of Windows support for some of our customers.
But both of them support ONNX exchange format, we can prototype and train in PyTorch and then deploy the model using Caffe2 CPU version.
I mostly agree that the results are not always good.
As someone who read the original style transfer paper, and implemented it, I disagree that it is applying a mechanical effect. Maybe I'm biased but the algorithm use a pre-trained CNN on object recognition.
The CNN develops a representation of the image that is more and more abstract along the layers of the network. You can visualize the information in each layer by reconstructing the image only from the feature maps. And when you do this you will see that the network, learns the objects and textures
of the image compared to its pixel values (pixels -> edges -> regions -> objects, etc).
As you can see from the output, the model can simplify the shape, alter the geometry, put a texture on an object (projecting a texture like UV mapping) without being explicitly programmed to do so. It is inherently different from Photoshop filters that apply a fixed transformation on the pixels.
The fundamental difference is that the model is able to abstract away from the pixel representation of the image and it can decorelate content and style.
Also, it is not necessarily more computationally intensive in the generation / forward phase.
Even in relatively new fields like machine learning, nearly every software that we use at work is written in C or is a wrapper around a C library, or in some cases in Fortran (a 60 years old programming language) : we use extensively PyTorch, torch, numpy, LAPACK, Scipy, etc.
Pytorch is awesome especially with automatic differentiation. We used to do the training in torch and then convert the trained model to caffe. The only problem is that the conversion script supports only torch 7.
I heard that at Facebook they experiment and do the training in pytorch and then they convert the model to caffe 2.
I hope they will release the conversion script.
One can have the kind of unsafe shared memory like C++ in OCaml by using a library like netmulticore. But the OCaml formalised memory model is offering the same kind of OCaml safety in multicore programs.
For your first point I'm not an advocate of using a single programming language for all kinds of things. But it's just my opinion.
In OCaml there is Lwt. It provides very light-weight cooperative threads. The context switches are very fast and composing cooperative threads allows the writing of highly asynchronous applications.
For instance, in the versions of Go prior to 1.5 goroutines used to run on a single core. And as of 1.5 the variable GOMAXPROCS can be set to the number of cores.
EDIT:clarify the difference between concurrency and parallelism.
F# is basically an OCaml clone. I wonder why it isn't called NCaml or something like that.
F# lacks some functional programming features the powerful macro system used for creating domain specific languages and extending the ocaml language.
Popular recommendation algorithm like collaborative filtering by matrix factorization takes into account the accounts for user and item biases (the simplest method is to normalize the ratings of a particular user by the average of ratings of that user).
I second on this. The multicore support is not far away. Right now we have a memory model for multicore OCaml and even a multicore OCaml ARM64 backend.
A lot of scientific computing is done in python (numpy) and even in Lua (using torch the great tensor library). Much of the computations are done in the GPU anyway.
We were just beginning to implement some linear algebra routines in ocaml for our library that parses text into structured data. This is a very good news. We will contribute back if we have any enhancements.
Locality sensitive hash is well known technique for approximate nearest search and dimensions reduction. Combining it with dnn may reduce the complexity of the dataset. But I don't know if in this setting the parameters of the lsh are learnable via backprop?
Vector representation are useful for many natural language processing tasks.
In word embedding like word2vec, GLoVE, fasttext for each word the algorithm learns an associated vector in dimension n (x1, x2, .., xn).
A word maybe close to another in one dimension (or a subspace) but far away in another one. Moreover good representation allows meaningful vector space arithmetic: Queen - Women == King
word representations are typically trained on very large unlabeled data, but once the algorithm learns the features you can use them for your small dataset.
EDIT: Add more explanations.
We used PNaCl to port some games to a Smart TV. It was a painful experience. Debugging chrome from a custom gdb, breaking changes from release to release, and some very subtle bugs in pepper API. But the final results were surprisingly not so awful.
OpenJDK remains an Oracle project and all contributors should sign the Oracle Contributor Agreement (OCA). Although, an agreement of this nature exists in some other open source communities. But I feel, hesitant to grant Oracle the following rights :
- License any patents bearing on your contributions to Oracle.
- Assert that you are legally entitled to grant Oracle these rights.
- Oracle have full copyright ownership of all the code in that project.