Important Update
Clarifying the difference between machine learning and artificial intelligence reveals important distinctions regarding many of the popular buzzwords in the field today. Let’s eliminate the confusion by establishing a simple hierarchy of terms. We can say that AI is the parent field of machine learning:
Artificial intelligence is a vast field of theories and methods, and to be perfectly clear: despite advertising exaggeration and hype, machine learning as it is today amounts to a small part of AI. One significant practical problem today is that the endeavor to advertise products dramatically distorts scientific information on the subject by equating machine learning with AI. For example, if you Google “artificial intelligence frameworks” you will get hits on Theano and TensorFlow. You did not Google “machine learning frameworks,” but you received a list of machine learning frameworks anyway, because people are in the business of selling this software, and they don’t care what you call it. These products are not comprehensive AI frameworks; they are limited to problems of machine learning, which are largely pattern recognition problems. Conflating the terms in the above list is disadvantageous.
Recently, many products are even advertised as autonomous! To get an idea of a truly autonomous self-driving car, imagine one that suddenly decides on its own to leave San Jose and drive up to Vancouver to take some nice pictures of the mountains in the Fall, and disappears! That is autonomy. Hopefully, we can look at a few of the research horizons of AI and quickly realize that machine learning does not even approach such lofty goals:
Although ML can do excellent pattern recognition and therefore defeat a human chess expert, it will never enjoy the game of chess nor satisfactorily emulate the emotions of a human player which gives rise to both the priority and significance of the game. It is not apparent to most humans that logic has dependencies! Logic itself arises from the presupposition of priorities and values. Indeed, although the broader field of AI proposes theories for constructing such machines, AI cannot escape Gödel’s incompleteness: logical-mathematical systems include statements that are accepted as true but which cannot be proven! Machine learning is a little more than old linear regression renamed.
Examining the “difference between machine learning and deep learning” again we find that the former is a refined and advanced subset of the latter. If we are talking about the “difference between machine learning and neural networks” we can see that the neural network is a method of deep learning. Cognitive neural networks are a further specialized subset. Furthermore, an effort to delineate the “difference between deep learning and neural networks” reveals once again that neural networks are a specific set of methods of deep learning, and so AI contains all of these by proxy.
Something a bit different happens when we study the “difference between data science and machine learning” because now we are looking at two broad fields of inquiry, and we find that data science includes AI to an extent and also shares many methods with machine learning. The difference between data mining and machine learning is more ambiguous because many techniques and methods of pattern recognition are commonly and almost equally labeled as one or the other.
Today, the difference between AI and machine learning is the single most important source of confusion in popular technical journals. Misconceptions about machine learning and deep learning differences are the second most abundant. Toward the goal of straightening out all the misconceptions, we will explore all three of these with an in-depth look at each.
After distinguishing the relationships among the various fields of inquiry as above, the associated development frameworks of each likewise fall into a similar order. A framework is an environment for creating applications and usually includes an IDE, one or more standard language interpreters, and compilers, and these tools further expose a vast array of standard libraries and modules for advanced coding. Clarifying the differences among popular frameworks results in a hierarchical structure similar to the one above, but we now need to include language interfaces and point out the difference between library and framework. In this article, we will look at the best-of-class frameworks:
When we talk about a library in the context of a programming language like Python, we include libraries like Scipy, Numpy, and Pandas, each of which contains a set of functions and methods to make coding projects efficient and convenient. Pandas, for example, contain the FrameData objects which make convenient the task of data representation in a form similar to MS Excel. Many of the same methods used in Excel are replicated in pandas. The Numpy library includes functions for efficient matrix math which is important to all the methods of machine learning.
A quick deep-learning framework comparison reveals the common overlap in concepts and produces hits including TensorFlow, Keras, PyTorch, and MXNet. Here we can see that the library and framework are two terms used interchangeably, and for practical purposes, there is no problem with doing so. Just keep in mind that you will likely see SciKitLearn described as a Python library as well as an ML framework. Likewise, a machine learning framework comparison will produce almost identical hits.
As for the most popular deep learning framework, the truth is perhaps impossible to discover, because proprietary frameworks have absorbed open-source frameworks, effectively concealing the frequency of their implementation. Also, the success of a deep learning project will depend on the accurate choice of machine learning methods for a specific set of data features rather than a framework. This is true because all of the popular frameworks contain the same popular methods, like K nearest neighbors, random forests, and deep belief neural networks. For instance, Wolfram’s machine learning framework absorbed MXNet and it is then distributed within a paid application. Not surprisingly, developers move from one company to another, taking their design methods with them, and after a few years of this mixing, all distributions look alike.
To speak of a “python machine learning framework” is to imply SciKit Learn machine learning library or another library designed to work with the Python language. Python is not inherently designed for AI, but many libraries and frameworks for AI, machine learning, and deep learning are easily implemented with Python. Our purpose here is to delineate this terminology and to provide a fundamental example as an illustration. Beyond Python, many languages are capable of implementing models of AI and machine learning including Lisp, Prolog, Java, and more. Now let’s look at the implementation of these tools.
To escape the hype of advertising and drive closer to more diverse research in true AI, we need to expand our vocabulary. The problem with Google is that you cannot search for something unless you know what it’s called; You can’t browse the internet the way you can browse a traditional library. This shortcoming makes us wonder why this app is called a browser! But fortunately, things can be discovered through serendipity. Lisp is the second-oldest high-level language in use today. After its inception became the preferred coding language for artificial intelligence research apps. Common Lisp is currently the most popular dialect. And Caveman2 is an open-source framework for Common Lisp with support for creating web applications. Caveman2 is free open-source software and is available through the Quicklisp package manager. Quicklisp is a package manager intended to support Common Lisp modules and libraries. Quicklisp implements a simple compatibility layer allowing Quicklisp to run with most Common Lisp implementations. It can also facilitate the download of some 1,400 related modules and libraries.
We want to demonstrate the use of a true AI framework with a code sample that pertains to an endeavor relevant in today’s AI context. Although it is not in the scope of this article to explain the syntax and functionality of Lisp, we can delineate some salient features and thus distinguish it from the throng of machine learning frameworks blaring in previously subtle places.
Coined from the phrase “list processing,” Lisp is practical for AI apps because of its great prototyping capabilities and facility for symbolic expression. Lisp is used in AI projects such as DART, Macsyma – one of the first symbolic algebra apps which were originally developed at MIT, and CYC, and is often used in medical diagnosis apps, one of the most difficult problems in machine intel. Here is an example List program to reverse the order of characters in a list:
(defun iterative-reverse (1st) ;; function reverse list with iteration (prog (temp) ;; temp local variable initialized to NIL LOOP (cond ((null 1st) (return temp))) ;; check for termination of 1st, add first element to temp (setq temp (cons (car 1st) temp)) ;; remove first element from 1st before looping (setq 1st (cdr 1st)) (terpri) (princ ' J Temp = ]) (princ temp) ;; print result (go LOOP)))
The parenthetical syntax is remarkable in Lisp. A feature annoying to some and quintessential to others, this aspect is little different than brackets in C++. The objects in Lisp are called atoms, and anything can be an atom. Likewise, functions and recursion are similar to other languages. In fact, most languages of today are capable of implementing logical and symbolic features similar to Lisp. For example, Reddit news was originally written in Common Lisp, but it was later rewritten in Python.
A typical implementation in Caveman2 to reference a JSON file HTTP request looks like this:
(defun char-vector-to-string (v)
(format nil "~{~a~}" (mapcar #'code-char (coerce v 'list))))
(defun remote-json-request (uri)
"Pull in remote JSON. Drakma returns it as a large vector of
character codes, so we have to parse it out to string form for
cl-json."
(let* ((json-response-raw (http-request uri))
(json-response-string (char-vector-to-string json-response-raw))
(json (decode-json-from-string json-response-string)))
json)
Caveman2 in conjunction with Quicklisp now provides functionality for developing web apps equivalent to Python and MXNet, for example. The nuances in the choice of language and framework are largely nominal today. One enterprise may favor Lisp because of a legacy of established code and engineers already familiar with the existing libraries. Freedom of choice is greatest at the point of the initial design.
As we have clearly established, the most popular machine learning frameworks today are equivalent in that they all include every popular method of ML and DL. This is imperative because of competition and is facilitated by the widespread availability of research documents that demonstrate the implementation of the methods. Conflating ML and DL is a trivial error, but artificial intelligence is a superset of both. The list of competing ML and DL frameworks grows every month, and it is astonishing that freeware programs should compete at all, which may serve to illustrate the wild popularity of the subject. Although the following list of frameworks is far from exhaustive it will demonstrate the point:
And we have not even mentioned the paid frameworks. The real choice of which method to choose to achieve the greatest accuracy in a given project must be based on a mathematical appraisal of the objectives. For example, cognitive neural network methods are better for natural language processing. Of the many regression methods here are four noteworthy varieties::
Artificial neural networks are pattern-matching algorithms used for regression as well as classification problems. To name a few:
Deep Learning methods constitute more recent improvements and innovations in classical ML methods. Targets are Big Data in the context of decreasing hardware costs. DLLs intend to increase the depth of ordinary neural networks and extend them to larger datasets. However, the methods are fundamentally the same, and include these popular examples::
Choosing any two frameworks from the above list and exploring a few example scripts will eventually prove that they are all fundamentally the same down to the pith. In this example, we will generate a small dataset with Shogun and Python:
from numpy import * from numpy.random import randn dist=0.499 trainingdata_real = concatenate((randn(2,1000)-dist1, randn(2,1000)+dist), axis=1) testdata_real = concatenate((randn(2,1000)-dist1, randn(2,1000)+dist), axis=1) train_labels = concatenate((-ones(1000), ones(1000))) test_labels = concatenate((-ones(1000), ones(1000)))
We first import numpy, and then generate a type of real-valued training and test data split based on a Gaussians distribution. Next, generate two Gaussian sets that are “dist” apart. We insert the data in a matrix with each column describing an object. Finally, we add labels. This simple setup can be replicated in an almost identical form in all of the frameworks listed.
All machine learning algorithms run fastest on GPU hardware because ML is modeled on matrix math and GPUs are optimized for matrix math. It’s the perfect match for software and hardware. NVIDIA Deep Learning SDK runs deep learning algorithms with this match in mind. Advanced deep neural networks use algorithms in conjunction with big data with the power of the GPU for apps like self-driving cars, where speed is crucial. Let’s look at an example of a PyTorch algorithm that accelerates n-dimensional tensors on GPUs. In the following Python code, we take advantage of PyTorch Tensors:
import torch
dtype01 = torch.FloatTensor
N, D_in, H, D_out = 64, 1000, 100, 10
x = torch.randn(N, D_in).type(dtype01)
y = torch.randn(N, D_out).type(dtype01)
w01 = torch.randn(D_in, H).type(dtype01)
w02 = torch.randn(H, D_out).type(dtype01)
learning_rate = 1e-6
for t in range(500):
h = x.mm(w01)
h_relu = h.clamp(min=0)
y_pred = h_relu.mm(w02)
loss = (y_pred - y).pow(2).sum()
print(t, loss)
grad_y_pred = 2.0 * (y_pred - y)
grad_w02 = h_relu.t().mm(grad_y_pred)
grad_h_relu = grad_y_pred.mm(w02.t())
grad_h = grad_h_relu.clone()
grad_h[h < 0] = 0
grad_w01 = x.t().mm(grad_h)
w01 -= learning_rate * grad_w01
w02 -= learning_rate * grad_w02
We begin by creating a random dataset to test the function. Next, we initialize weights, bias, and calculate the loss. We then use backpropagation with the weights, and finally, we refine the weights with each loop through gradient descent. This is a real breakthrough when running in the GPU.
The core concept in managing datasets in the Caffe2 Framework is Blobs. The purpose is a fundamental reorg through naming data chunks as tensors.
from caffe2.python import workspace, model_helper
import numpy as np01
x = np01.random.rand(4, 3, 2)
print(x)
print(x.shape)
workspace.FeedBlob("my x val", x)
x2 = workspace.FetchBlob("my x val")
print(x2)
In the above code sample, we demonstrate the capability to initialize a tensor in 3-space with a random dataset (a similar concept to the previous Torch sample). Next, we need to demo the Net object. Caffe2 nets are operator graphs, a unique mechanism to mitigate input blobs and output blobs through the learning model. Look at this example:
# Input data:
data = np01.random.rand(16, 100).astype(np01.float32)
# Label data as integers [0, 9].
label = (np01.random.rand(16) * 10).astype(np01.int32)
workspace.FeedBlob("data - ", data)
workspace.FeedBlob("label - ", label)
Next, we create the model, and initiate weights and biases:
m = model_helper.ModelHelper(name="Caffe2 net:") weight01 = m.param_init_net.XavierFill([], 'fc_w', shape=[10, 100]) bias01 = m.param_init_net.ConstantFill([], 'fc_b', shape=[10, ])
Finally, we implement the model as:
fc_1 = m.net.FC(["data", "fc - w", "fc - b"], "fc1") pred = m.net.Sigmoid(fc - 1, "pred") softmax, loss = m.net.SoftmaxWithLoss([pred, "label"], ["softmax", "loss"])
Caffe2’s implementation uses a standard Softmax regression to generate the model parameters. The frameworks establish unique features, but in the end, nearly all of them use highly efficient Softmax for the regression.
Hopefully, it is now apparent that machine learning is not intelligent. However, the more practical point is a realistic appraisal of the difference between artificial intelligence as an advanced field of computer science and the implementations of machine learning which are commonplace in open-source frameworks now. Today a common task of ML can be generalized as, “inferring a function to describe hidden structures from the unlabelled data.” This strategy may reveal surprising forecasts that a company can profit from immediately purchasing a fleet of vehicles, but it will not cause the machine to choose the decision not to buy the vehicles on the longer-term basis that it is destructive to the environment; the former is a common machine learning task and the latter requires actual intelligence. Field and subfield are thus differentiated. The latter is a level of intelligence not yet on the AI horizon. It is speculative.
Humans are now backward-adaptive, which means that humans are changing their goals and altering their behavior to compensate for the inadequacies of machine intelligence! Humans are effectively lowering the standard definition of intelligence to equivocate the current definition of machine intelligence. As humans develop increasingly intelligent systems while simultaneously backward-adapting themselves the result may be that machines and humans of the future meet somewhere in between today’s concepts of natural and artificial intelligence, through an unfortunate evolutional proxy. What the true future of AI holds in the store may depend more on the advent of the quantum computer than on the development of AI algorithms!
About the Author
ByteScout Team of Writers
ByteScout has a team of professional writers proficient in different technical topics. We select the best writers to cover interesting and trending topics for our readers. We love developers and we hope our articles help you learn about programming and programmers.
Software project management tools are software tools that help automate the process of the software development lifecycle. The development process involves many intricacies ranging from...
Humans understand the image and its content by merely looking at it. Machines do not work the same way. It needs something more tangible, organized...