Cognitive RPA (Robotic Process Automation), as the name itself, suggests, provides intelligence to conventional RPA. Conventional RPA is extremely good at automating rule-based tasks involving structured and semi-structured data.
However, with enterprise processes being highly complex and technologically intertwined, utilizing both structured and unstructured data becomes complicated. It is imperative that only the RPA solution would not suffice. The digital workforce (Bots) would be required to make complex decisions that involve learning, reasoning, and self-healing capabilities.
In a nutshell,Cognitive RPAis RPA on steroids. It utilizes artificial intelligence technologies like computer vision, OCR (Optical Character Recognition), document understanding,NLP (Natural Language Processing), Text Analytics, and numerous custom-built or out-of-the-box Machine learning & Deep Learning models that help bots make complex decisions while automating an end-to-end process.
In addition, many vendors are providing Human in Loop capabilities where the output ofAI/ML modelsis validated by humans (Business SME), and post their approval, bots take the automated process to its completion.
Along with automating web-based applications, RPA can also automate Windows applications and legacy applications, for which developing IT integration would be a cost-intensive, time-consuming and gargantuan task. RPA can mimic what an end-user does with near-zero errors and without being fatigued, bored, or roguelike humans. It offers higher accuracy, increased performance, increased adherence to SLA, and better compliance. With this amalgamation of AI and RPA (Cognitive RPA), we can now automate end-to-end processes and can handle complex cases which would have earlier required human interventions.
The main goal of Cognitive RPA is to take up all mundane, repetitive, and tedious tasks from humans so that they can focus on more strategic tasks rather than worrying about the former. The motto is “If you hate it, just automate it.”
New Subscriber Verification: Individual’s identity-related information is extracted from the submitted proof image and is matched against user input for any discrepancies. Moreover, the individual’s picture in ID proof is matched with their current picture and against pictures of fraudsters to verify the new subscriber’s identity.
Invoice Processing: Extracts vital information from invoices like Bill To, Ship To, Due Date, Invoice, line items, total, etc., to run an audit against system entries by reconciling extracted information against them.
Digital Assistant: Identifies failed jobs and takes remediation actions by understanding from underlying logs.
FCR (First Call Resolution): Resolving customer’s concerns from the first call to a customer care center, bots can assist employees by offering real-time guidance (retrieving customer information, re-keying updated information, trigger issue to resolution workflow for known issues, etc.).
Information Security Audits: Bots can easily collect evidence (logs, database records, flat files, etc.) across disparate systems and analyze them for any non-conformities against set enterprise policies, procedures, and guidelines.
We, at Subex, help customers realize value from Cognitive RPA implementation. We play the role of Trusted Advisor helping clients with Process discovery (identifying the process), Evaluation and Selection of the process – fit for RPA, Process Standardization (creation of user-friendly templates, documentation, communication plans, etc.), even Process Re-Engineering if required. Post finalization of the process for automation; High Level and Low-Level Designs are created in constant consultation with Business / Process SME. After rigorous iterative development and testing cycles, the full-fledge RPA solution is delivered so that customers can reap full benefits from it. We also undertake consulting assignments helping enterprises set up RPACoE (Center of Excellence), Scale-Up their RPA journey, and assist them in stepping forward from conventional RPA to Cognitive RPA.
But first, let’s address the question, “What is computer vision?” In simple terms, computer vision trains the computer to visualize the world just like we humans do. Computer vision techniques are developed to enable computers to “see” and draw analysis from digital images or streaming videos. The main goal of computer vision problems is to use the analysis from the digital source data to convert it into something about the world.
Computer vision uses specialized methods and general recognition algorithms, making it the subfield of artificial intelligence and machine learning. Here, when we talk about drawing analysis from the digital image, computer vision focuses on analyzing descriptions from the image, which can be text, object, or even a three-dimensional model. In short, computer vision is a method used to reproduce the capability of human vision.
Deep Neural Networks Addressing 8 Challenges in Computer Vision
As studied earlier, computer networks are one of the most popular and well-researched automation topics over the last many years. But along with advantages and uses, computer vision has its challenges in the department of modern applications, which deep neural networks can address quickly and efficiently.
1. Network Compression
With the soaring demand for computing power and storage, it is challenging to deploy deep neural network applications. Consequently, while implementing the neural network model for computer vision, a lot of effort and work is put in to increase its precision and decrease the complexity of the model.
For example, to reduce the complexity of networks and increase the result accuracy, we can use a singular value decomposition matrix to obtain the low-rank approximation.
2. Pruning
After the model training for computer vision, it is crucial to eliminate the irrelevant neuron connections by performing several filtrations of fine-tuning. Therefore, as a result, it will increase the difficulty of the system to access the memory and cache.
Sometimes, we also have to design a unique collaborative database as a backup. In comparison to that, filter-level pruning helps to directly refine the current database and determine the filter’s importance in the process.
3. Reduce the Scope of Data Values
The data outcome of the system consists of 32 bits floating point precision. But the engineers have discovered that using the half-precision floating points, taking up to 16 bits, does not affect the model’s performance. As the final solution, the range of data is either two or three values as 0/1 or 0/1/-1, respectively.
The computation of the model was effectively increased using this reduction of bits, but the challenge remained of training the model for two or three network value core issues. As we can use two or three floating-point values, the researcher suggested using three floating-point scales to increase the representation of the network.
4. Fine-Grained Image Classification
It is difficult for the system to identify the image’s class precisely when it comes to image classification. For example, if we want to determine the exact type of a bird, it generally classifies it into a minimal class. It cannot precisely identify the exact difference between two bird species with a slight difference. But, with fine-grained image classification, the accuracy of image processing increases.
Fine-grained image classification uses the step-by-step approach and understanding the different areas of the image, for example, features of the bird, and then analyzing those features to classify the image completely. Using this, the precision of the system increases but the challenge of handling the huge database increases. Also, it is difficult to tag the location information of the image pixels manually. But in comparison to the standard image classification process, the advantage of using fine-grained classification is that the model is supervised by using image notes without additional training.
5. Bilinear CNN
Bilinear CNN helps compute the final output of the complex descriptors and find the relation between their dimensions as dimensions of all descriptors analyze different semantic features for various convolution channels. However, using bilinear operation enables us to find the link between different semantic elements of the input image.
6. Texture Synthesis and Style Transform
When the system is given a typical image and an image with a fixed style, the style transformation will retain the original contents of the image along with transforming the image into that fixed style. The texture synthesis process creates a large image consisting of the same texture.
a. Feature Inversion
The fundamentals behind texture synthesis and style transformation are feature inversion. As studied, the style transformation will transform the image into a specific style similar to the image given using user iteration with a middle layer feature. Using feature inversion, we can get the idea of the information of an image in the middle layer feature.
b. Concepts Behind Texture Generation
The feature inversion is performed over the texture image, and using it, the gram matrix of each layer of the texture image is created just like the gram matrix of each feature in the image.
The low-layer features will be used to analyze the detailed information of the image. In contrast, the high layer features will examine the features across the larger background of the image.
c. Concept Behind Style Transformation
We can process the style transformation by creating an image that resembles the original image or changing the style of the image that matches the specified style.
Therefore, during the process, the image’s content is taken care of by activating the value of neurons in the neural network model of computer vision. At the same time, the gram matrix superimposes the style of the image.
d. Directly Generate a Style Transform Image
The challenge faced by the traditional style transformation process is that it takes multiple iterations to create the style-transformed image, as suggested. But using the algorithm which trains the neural network to generate the style transformed image directly is the best solution to the above problem.
The direct style transformation requires only one iteration after the training of the model ends. Also, calculating instance normalization and batch normalization is carried out on the batch to identify the mean and variance in the sample normalization.
e. Conditional Instance Normalization
The problem faced with generating the direct style transformation process is that the model has to be trained manually for each style. We can improve this process by sharing the style transformation network with different styles containing some similarities.
It changes the normalization of the style transformation network. So, there are numerous groups with the translation parameter, each corresponding to different styles, enabling us to get multiple styles transformed images from a single iteration process.
7. Face Verification/Recognition
There is a vast increase in the use cases of face verification/recognition systems all over the globe. The face verification system takes two images as input. It analyzes whether the images are the same or not, whereas the face recognition system helps to identify who the person is in the given image. Generally, for the face verification/recognition system, carry out three basic steps:
Analyzing the face in the image
Locating and identifying the features of the image
Lastly, verifying/recognizing the face in the image
The major challenge for carrying out face verification/recognition is that learning is executed on small samples. Therefore, as default settings, the system’s database will contain only one image of each person, known as one-shot learning.
a. DeepFace
It is the first face verification/recognition model to apply deep neural networks in the system. DeepFace verification/recognition model uses the non-shared parameter of networks because, as we all know, human faces have different features like nose, eyes, etc.
Therefore, the use of shared parameters will be inapplicable to verify or identify human faces. Hence, the DeepFace model uses non-shared parameters, especially to identify similar features of two images in the face verification process.
b. FaceNet
FaceNet is a face recognition model developed by Google to extract the high-resolution features from human faces, called face embeddings, which can be widely used to train a face verification system. FaceNet models automatically learn by mapping from face images to compact Euclidean space where the distance is directly proportional to a measure of face similarity.
Here the three-factor input is assumed where the distance between the positive sample is smaller than the distance between the negative sample by a certain amount where the inputs are not random; otherwise, the network model would be incapable of learning itself. Therefore, selecting three elements that specify the given property in the network for an optimal solution is challenging.
c. Liveness Detection
Liveness detection helps determine whether the facial verification/recognition image has come from the real/live person or a photograph. Any facial verification/recognition system must take measures to avoid crimes and misuse of the given authority.
Currently, there are some popular methods in the industry to prevent such security challenges as facial expressions, texture information, blinking eye, etc., to complete the facial verification/recognition system.
8. Image Search and Retrieval
When the system is provided with an image with specific features, searching that image in the system database is called Image Searching and Retrieval. But it is challenging to create an image searching algorithm that can ignore the slight difference between angles, lightning, and background of two images.
a. Classic Image Search Process
As studied earlier, image search is the process of fetching the image from the system’s database. The classic image searching process follows three steps for retrieval of the image from the database, which are:
Analyzing appropriate representative vectors from the image
Applying the cosine distance or Euclidean distance formula to search the nearest result and find the most similar image representative
Use special processing techniques to get the search result.
The challenge faced by the classic image search process is that the performance and representation of the image after the search engine algorithm are reduced.
b. Unsupervised Image Search
The image retrieval process without any supervised outside information is called an unsupervised image search process. Here we use the pre-trained model ImageNet, which has the set of features to analyze the representation of the image.
c. Supervised Image Search
Here, the pre-trained model ImageNet connects it with the system database, which is already trained, unlike the unsupervised image search. Therefore, the process analyzes the image using the connection, and the system dataset is used to optimize the model for better results.
d. Object Tracking
The process of analyzing the movement of the target in the video is called object tracking. Generally, the process begins in the first frame of the video, where a box around it marks the initial target. Then the object tracking model assumes where the target will get in the next frame of the video.
The limitation to object tracking is that we don’t know where the target will be ahead of time. Hence, enough training is to be provided to the data before the task.
e. Health Network
The usage of health networks is just similar to a face verification system. The health network consists of two input images where the first image is within the target box, and the other is the candidate image region. As an output, the degree of similarity between the images is analyzed.
In the health network, it is not necessary to visit all the candidates in the different frames. Instead, we can use a convolution network and traverse each image only once. The most important advantage of the model is that the methods based on this network are high-speed and can process any image irrespective of its size.
f. CFNet
CFNet is used to elevate the tracking performance of the weighted network along with the health network training model and some online filter templates. It uses Fourier transformation after the filters train the model to identify the difference between the image regions and the background regions.
Apart from these, other significant problems are not covered in detail as they are self-explanatory. Some of those problems are:
Image Captioning: Process of generating short description for an image
Visual Question Answering: The process of answering the question related to the given image
Network Visualizing and Network Understanding: The process to provide the visualization methods to understand the convolution and neural networks
Generative Models: The model use to analyze the distribution of the image
There is a tendency, even among people who should know better, to view the data that one has access to in an organization as being of perfect quality and utility. In reality, the data that any organization collects over time can range from being highly useful to a waste of computer cycles and processing effort, and an effective part of any data strategy is understanding what is a treasure and what is, to put it simply, an eyesore..
1. Entropy
Entropy is a measure of uncertainty associated with random variables.
Example: The meteorology department wants to tell whether it’s going to rain or not today. And they have the weather data collected from various devices. The data has attributes of wind, pressure, humidity and precipitation.
If you pick one value from the series of Humidity values, how certainly can it tell when it is going to rain or not? Is the entropy associated with Humidity random variable.
If entropy is too high,it indicates the Humidity variable has not potential to tell that it’s going to rain or not. If entropy is less, then Humidity is a good variable to be considered in further analysis.
2. Outliers
Outlier is a measure of unusualness associated with a random variable.
Though Humidity has a good potential to solve the problem, not all of it’s values can be useful to the calculation. Create a boxplot and determine the number of outliers.
If more percentage of values are lying outside the box, then the final outcome would be less accurate. In such a case, we need to discard the Humidity variable. Take one more variable and start with Entropy test.
3. Covariance
Covariance is a measure of relationship between two variables. How variable X changes when variable Y changes. X and Y may have different units of measurements.
Example, if Humidity decrease as Wind increases, then there is a relationship between Humidity and Wind. This relationship adds more value in solving the problem.
How many variables are there that have covariance with at least one other variable is the count we need to measure. Higher this count, more evidence we can derive towards the final outcome.
Good Dataset:
More number of variables that have strong covariance with few/more other variables.
Bad Dataset:
Less number of variables that have strong covariance with few other variables.
More number of variables that have weak covariance with many other variables.
A possible outcome of this assessment could like this:
Humidity has potential to certainly tell it rains or not.
Wind has potential to certainly tell it rains or not.
Most of the values of Humidity & Wind can participate in the calculation. The accuracy is within the acceptable limits.
Humidity and Wind Together has more potential to drive the decision — whether it rains or not.
Finally you need to ask these questions to yourself, and feel satisfied with the answers:
I’m relatively old school, semantically speaking: my first encounters with RDF was in the early 2000s, not long after Tim Berners-Lee’s now-famous article in Scientific American introducing the Semantic Web to the world. I remember working through the complexities of RDFS and OWL, spending a long afternoon with one of the editors of the SPARQL specification in 2007, promoting SPARQL 1.1 and SHACL in the mid-2010s, and watching as the technology went from being an outlier to having its moment in the sun just before COVID-19 hit.
I like SPARQL, but increasingly I have to admit a hard reality: there’s a new kid on the block that I think may very well dethrone the language, and perhaps even RDF. I’m not talking about Neo4J’s Cypher (which in its open incarnation is intriguing), or GQL, TigerGraph’s SQL-like language intended to bring SQL syntax to graph querying. Instead, as the headline suggests, I think that the king of the hill will likely end up being GraphQL.
The Semantic Web Is In Trouble
Before getting a lot of brickbats from colleagues in the community about this particular assertion, I want to lay out some of my own observations about where and why I believe the Semantic Web is currently in trouble:
Too Complex. It took me a few years to really grok how RDF worked, in part because it assumed that people would be able to understand the graph paradigm and logical inferencing models. If you have a Ph.D. in computational linguistics, RDF is not hard to understand, but if you have a two-year certificate in programming JavaScript or Python, chances are pretty good that RDF’s graph model is incomprehensible. Add into that configuring triple store graphs can be a logistical nightmare and the likelihood that most programmers – let alone data analysts – would have encountered RDF drops dramatically.
Inference an Edge Case. One of the most powerful aspects of RDF, at least as far as proponents of the technology would have it, is its ability to be used for logical inferencing. Inferencing, which involves the ability to use aspects of the model itself to surface new information, can make for some very potent applications, but only if the model itself is navigable in the same way as other information, and only if the model is designed to make such inferences easily. However, in practice, many complex models have foundered because inheritance was made too complicated or the models failed to take into account temporal complexities. Moreover, with SPARQL, the need for intrinsic inferencing dropped fairly dramatically. Without that use case, though, many of the benefits of RDF fall by the wayside.
Lack of Intrinsic Sequencing. RDF works upon the (admittedly valid) assumption that in a graph there is no intrinsic ordering. It is possible to create extrinsic ordering by creating a linked list, but because path traversal order is not in fact uniformly respected, retaining this via SPARQL is not guaranteed. Since there are a great number of operations where sequencing is in fact very important, this limitation is a significant one, and in a world where object databases (which support arrays or sequences) are increasingly the norm, there are many analytics-related activities that simply cannot be done on the current crop of knowledge bases.
Use Case Failures. I’ve been involved in a number of semantics projects over the years. Most of them had, at best, mixed success, and several have been abject failures that have since been superseded by other technologies. Natural language processing seemed, a decade ago, to be a bright spot in the semantic web firmament, but if you look at the field ten years later, most of the real innovations have had to do with machine learning, from BERT to the latest GPT-3. There are places where graph technology has made huge inroads, but increasingly those areas are built around labeled property graphs, not rdf graphs. There are areas where knowledge graphs could make a huge difference (compliance modeling, for instance), but when no one can agree to what exactly those models look like, it’s not surprising that areas such as smart contracts are simply not getting off the ground.
Poor Format Interoperability. RDF is an abstraction language, but it has been dependent upon various and sundry representations, many of which have … issues. RDF-XML made even hardened XML users squeamish. Turtle is an elegant little language until one has to manage namespaces, but it has comparatively few people who have adopted it, and it doesn’t do terribly well in an environment where JSON is the dominant mode of communication. JSON-LD was a nice try. In most cases, the issues involved come down to the fact that JSON is an object description language that assumes hierarchical folding, while RDF is fundamentally normalized, and that especially with complex directed graphs, the boundaries between objects is far from clearcut in many cases.
Lack of Consistent Ingestion. This is a two-fold problem. It is hard to ingest non-RDF content into an RDF form. Part of this has been that the process of ingestion was never really defined from the outset since the assumption at the time was that you loaded in Turtle (or even more primitive representations) and then made use of inference upon an existing body of assertions. Once you move beyond the idea of static content, then all of the complexities of transactional databases have to be solved for triple stores as well. There have been many good solutions, mind you, but there was no real uniformity that emerged.
Graph databases are powerful tools, especially in a world of high data connectivity, but it is increasingly becoming evident that even for knowledge bases, it’s time to refactor.
The Promise of GraphQL
I started working with RDF about the time that I came to a realization about another query language (XQuery) and the nature of documents in an XML world. An XML database is typically a collection of documents, each with its own URL. That URL (uniform resource locator) was also an IRI (international resource identifier). For narrative documents, the assumption that every subdocument (such as a chapter) was self-contained in the base document was generally a valid one, though there were exceptions (especially in textbook publishing). Once you start dealing with documents that describe other kinds of entities, however, this assumption broke down, especially when multiple containers referenced the same subdocument.
While the concept of the IRI is a fundamental one in XML, it took a while to build a semantic linking language, and there were several different attempts that went off in different directions (xlink, rdf, rdfa, xpointer and so forth). Part of the reason for this confusion comes from the fact that most people don’t differentiate even now between a link pointer to a node in a communications network (the Internet, or some subsection thereof) and a link pointer to a node in a knowledge (or conceptual) network. Nor should this be that surprising – it’s not a distinction that usually comes up in database theory, because most databases are internally consistent with respect to references (aka keys or pointers), and the idea of conceptual links makes no sense in a SQL database as a consequence.
Additionally, if you are used to working with document object serializations, such as JSON, then the idea of having to create complex queries just to get specific objects of a given type seems like a lot of work, especially when the result comes back normalized (e.g., in discrete, identified blocks) rather than in hierarchical documents – and especially when you could already get back the same thing from a JSON database such as Couchbase or ArrangoDB.
For the most part, in fact, what developers want is a way to get at a particular part of a document, applying transformations to that document as needs be, without having to worry about stitching a set of components together. Similarly, they want to be able to post content in such a way that it can be checked for validity. They could do this with XQuery, but XML notationally is seen as too heavy-weight (an argument with comparatively little merit), whereas JSON fits into the paradigm that they are most familiar with syntactically.
This is what GraphQL promises, and for a fairly wide array of use cases, this is what both programmers and data scientists want.
What is significant about this is that GraphQL manages to accomplish much of what Sparql and the RDF stack promised but never fully delivered. Specifically,
Ease of Use. GraphQL requires both a client and a server to build the query, but that client makes schematic discovery relatively simple,
Data Store Agnostic. GraphQL can work on a relational database, a triple store, an Excel document, or a data service, for both ingestion and query.
Transformable. There is a limited capability to perform transformations on the data set through both the query and mutation language.
Mutable. Mutations for updating content on the server can be accomplished through a mutational query that is again system agnostic.
Schematic. While not quite as robust as RDF, GraphQL makes use of TypeScript or JSON Schema to specify the schematic relationships, and can be validated prior to entry.
JSON-Centric. A decade ago, there was still some question about whether XML or JSON would predominate. Today, there is no real question – for non-narrative content, JSON has pretty much won, while XML is (not surprisingly) still favored for narrative content, if not as heavily.
Federated. It is possible (with extensions) to make GraphQL queries federated. SPARQL still has the edge here, but federation is also still not widely utilized even in RDF-land.
Put another way, GraphQL provides an abstraction layer that is good enough in most cases, and preferable in others (such as sequencing) to what SPARQL provides.
GraphQL and Knowledge Graphs
This does not necessarily mean that GraphQL will eliminate the need for knowledge graphs or RDF, but it does change the role that languages such as Sparql, Cypher, or similar dialects play. One aspect where this does play a significant role is in creating GraphQL schemas. A relational database schema is generally fixed by convention, while both XML and JSON schemas when they do exist, do so primarily as a means of initiating actions based upon compliance with rules. Typescript is simply not robust enough for that role when it involves constraint modeling, and given the variability involved in different data systems, it is likely that this particular function will remain the purview of the data store.
Similarly, inferencing involves the construction of triples through either an inference engine or a SPARQL script (or both). One of the major issues working with Triple Stores is the security aspect involved with queries. If, when the underlying data model changes, a SPARQL script is used to construct a TypeScript document from the RDF schema, then this actually provides a layer of protection. The RDF models an internal state, The GraphQL models an external representation of that state.
This also can also help with mutations, providing a proxy layer that can map between the internal and external presentation of the state of the knowledge graph. SPARQL Update is a powerful tool, but because that tool is so powerful it is one that many database administrators are reluctant to grant to external users. This also allows for the insertion of additional metadata and or the creation of maps between JSON content and RDF in a consistent and controlled manner, including the generation of consistent timestamps and IRIs.
Additionally, an increasing number of GraphQL implementations on Knowledge Graphs make use of the JSON-LD context object. This provides a way of maintaining IRIs without significantly impacting the utility of the JSON produced by GraphQL. That approach also solves one of the peskier aspects of JSON-LD, in that a GraphQL generated JSON structure can be denormalized, reducing the need to do so out of band.
The Future of Semantic GraphQL
Nonetheless, GraphQL will likely push the engines involved with RDF towards JSON/hybrid stores over the next few years. Triple stores in general are built around n-tuple indexes, though with additional indexes encoding intermediate structures optimized for JSON retrieval. These so-called hybrid databases can also present service layers to look like relational data stores, albeit with some potential lossiness.
This also points to a future where federated queries become less likely, rather than more, which shouldn’t be all that surprising. Federation has a lot of issues associated with it, from semantic ones (the challenge of standardizing on a particular ontology) to performance issues (latency in connections) to security and accessibility. However, with GraphQL, the cost of developing a translation layer becomes fairly low and the onus is put not on the data provider but the data consumer. Indeed, I can see an aftermarket for common ontology to ontology queries, which may very well mitigate one of the bigger headaches involved in linked data.
GraphQL may also end up being a bridge between semantic and labeled property graph (LPG) operations. While it is possible to do shortest path calculations in an RDF graph, it’s not the most efficient way of utilizing such graph (indeed, shortest path calculations, used in everything from traffic applications to genetic sequencing are essentially where LPGs excel. On the other hand, LPGs are at best indifferent for inferencing. Yet GraphQL could readily load LPGs with data pulled from property graphs, could perform multiple optimizations, then could return the results through a known interface.
Finally, it is possible that we’re on the right track with regards to true reasoning as a system of computation on logical formalisms, but my suspicion is that reasoning requires that you have context, the ability to work with fuzzy logic, and the kind of Bayesian analysis that seems to be the hallmark of machine learning. In other words, the semantic systems of today are likely at best very primitive approximations of where they will be in a decade or two. Indeed, this was something that mathematician Kurt Godel proved nearly a century ago. We learn from that, build on to it, and move on.
Regardless, I think it is safe to say that, regardless of where we end up, GraphQL will likely have an important part to play in getting there.
Kurt Cagle is the managing editor of Data Science Central.
Programmers, when first learning their trade, spend a few weeks or months working on the basics – the syntax of the language, how to work with strings and numbers, how to assign variables, and how to create basic functions. About this time, they also encounter two of their first data structures: lists and dictionaries.
Lists can be surprisingly complex structures, but in most cases, they consist of sequences of items with pointers (or links) from one item to the next. While navigation can be handled by traversing the linked list (also known as an array), most often this is shortcircuited by passing in a numeric index that can be given from 0 (or 1 in some languages) to the position of whatever item is required.
A similar structure is known as a dictionary. In this particular case, a dictionary takes a symbol rather than a position indicator and returns an item. This is frequently referred to as a look-up table. The symbol, or key, can be a number, a word, a phrase, or even a set of phrases, and once the keys are given, the results can vary from a simple string to a complex object. Almost every database on the planet makes use of a dictionary index of some sort, and most databases actually have indexes that in turn are used to look up other indexes.
One significant way of thinking about indexing is that an index (or a dictionary) is a way of storing computations. For instance, in a document search index, the indexer will read through a document as it is loaded, then every time a new word or phrase occurs (barring stop words such as articles or prepositions) that word is used to indicate the document. The indexer will also pick up stem forms of a given word (which are indexed to a root term) so that different forms of the same word will be treated as one word.
This is a fairly time-consuming task, even on a fast processor, but the advantage to this approach is that once you have performed it once, then you only need do it again when the document itself changes. Otherwise, instead of having to search through the same document every time a query is made, you instead search the index, find which documents are indexed by the relevant keywords, then retrieve those documents within milliseconds. You can even use logical expressions to string keywords together, finding either the union or intersection of documents that satisfy that expression, and then return pointers to just the corresponding documents.
Machine learning, in this regard, can be seen as being another form of index, especially when such learning is done primarily for classification purposes. The training of a machine learning model is very much analogous to the processing of documents into an index for word usage or semantic matching, save that what is being consumed are test vectors, and what is produced is the mapping of a target vector to a given configuration.
Additionally, natural language processing is increasingly moving towards models where context is becoming important, such as Word2Vec, BERT, and most recently the GPT-2 and GPT-3 evolutions. These are shifting from statistical modeling and semantic analysis to true neural networks, with context coming about in part by the effective use of indexing. By being able to identify, encode, and then reference abstract tokenization of linguistic patterns in context, the time-consuming part of natural language understanding (NLU) can be done independently of the utilization of these models.
A query, in this regard, can also be seen as being a key, albeit a more sophisticated one. In RDF semantics, for instance, the queries involve finding patterns in linked indexes, then using these to retrieve assertions that can be converted into data objects (either tables or structured content). Graph embeddings present another approach to the same problem. It is likely that the next stage of evolution in this realm of search and query will be the creation of dynamically generated queries against machine learning models, in essence treating the corresponding machine learning model into a contextual database that can be mined for inferential insight.
In that regard, neural-network-based machine learning systems will increasingly take on the characteristics of indexed databases, in a manner similar to that currently employed by SQL databases, structured document repositories, and n-tuple data stores. At this point, such query systems are likely still a few years out, but the groundwork is increasingly leaning towards the notion of model as database.
This in turn will drive applications driven by such systems, in both the natural language understanding realm (NLU) and the natural language generation (NLG) one. It is my expectation that these areas, perhaps more even than automated visual recognition, will become the hallmark of artificial intelligence in the future, as the understanding of language is essential to the development of any cognitive social infrastructure.
This article focuses on the machine learning aspects of the problem, and the use of pattern recognition techniques leading to very interesting, new findings about twin primes. Twin primes are prime numbers p such that p + 2 is also prime. For instance, 3 and 5, or 29 and 31. A famous, unsolved and old mathematical conjecture states that there are infinitely many such primes, but a proof still remains elusive to this day. Twin primes are far rarer than primes: there are infinitely more primes than there are twin primes, in the same way that that there are infinitely more integers than there are prime integers.
Here I discuss the results of my experimental math research, based on big data, algorithms, machine learning, and pattern discovery. The level is accessible to all machine learning practitioners. I first discuss my experimentations in section 1, and then how it relates to the twin prime conjecture, in section 2. Mathematicians may be interested as well, as it leads to a potential new path to prove this conjecture. But machine learning readers with little time, not curious about the link to the mathematical aspects, can read section 1 and skip section 2.
I do not prove the twin prime conjecture (yet). Rather, based on data analysis, I provide compelling evidence (the strongest I have ever seen), supporting the fact that it is very likely to be true. It is not based on heuristic or probabilistic arguments (unlike this version dating back to around 1920), but on hard counts and strong patterns.
This is not different from analyzing data and finding that smoking is strongly correlated with lung cancer: the relationship may not be causal as there might be confounding factors. In order to prove causality, more than data analysis is needed (in the case of smoking, of course causality has been firmly established long ago.)
1. The Machine Learning Experiment
We start with the following sieved-like algorithm. Let SN = { 1, 2, …, N } be the finite set consisting of the first N strictly positive integers, and p be a prime number. Let Ap be a strictly positive integer, smaller than p. Remove from SN all the elements of the form Ap, p + Ap, 2p + Ap, 3p + Ap, 4p + Ap and so on. After this step, the number of elements left will be very close to N (p – 1) / p = N (1 – 1/p). Now, remove all elements of the form p – Ap, 2p – Ap, 3p – Ap, 4p – Ap and so on. After this step, the number of elements left will be very close to N (1 – 2/p). Now pick up another prime number q and repeat the same procedure. After this step, the number of elements left will be very close to N (1 – 2/p) (1 – 2/q), because p and q are co-prime (because they are prime to begin with.)
If you repeat this step for all prime numbers p between p = 5 and p = M (assuming M is a fixed prime number much smaller than N, and N is extremely large and you let N tends to infinity) you will be left with a number of elements that is still very close to
where the product is over prime numbers only.
Let us introduce the following notations:
S(M, N) is the set left after removing all the specified elements, using the above algorithm, from SN
C(M, N) is the actual number of elements in S(M, N)
D(M, N) = P(M, N) – C(M, N)
R(M, N) = P(M, N) / C(M, N)
In the context of the twin prime conjecture, the issue is that M is a function of N, and the above very good approximation, that is, replacing C(M, N) by P(M, N), is no longer good. More specifically, in that context, M = 6 SQRT(N), and Ap = INT(p/6 + 1/2) where INT is the integer part function. The ratio R(M, N) would still be very close to 1 for most choices of Ap, assuming M is not too large compared to N, unfortunately, Ap = INT(p/6 + 1/2) is one of the very few for which the approximation fails. On the plus side, it is also one of the very few that leads to a smooth, predictable behavior for R(M, N). This is what makes me think it could lead to a prove of the twin prime conjecture. Note that if M is very large, much larger than N, say M = 6N, then C(M, N) = 0 and thus R(M, N) is infinite.
Below is a plot displaying D(M, N) at the top, and R(M, N) at the bottom, on the Y-axis, for N = 400,000 and M between 5 and 3,323 on the X-axis. Only prime values of M are included, and Ap = INT(p/6 + 1/2).
It shows the following patterns:
For small values of M, R(M, N) is very close to 1.
Then as M increases, R(M, N) experiences a small dip, followed by a maximum at some location M0 on the X-axis. Then it smoothly decreases well beyond the critical value M1 = 6 SQRT(N). It reaches a minimum at some location M2 (not shown in the plot) followed by a rebound, increasing again until M3 = 6N, where R(M, N) is infinite. The value of M0 is approximately 3 SQRT(N) / 2.
To prove the twin prime conjecture, all is left if the following: proving that M0 < M1 (that is, the peak always takes place before M1, regardless of N) and that R(M0, N), as a function of N, does not grow too fast. It seems the growth is logarithmic, but even if R(M0, N) grows as fast as N / log^3(N), this is slow enough to prove the twin prime conjecture. Detailed explanations are provided in section 2.
The same patterns are also present if you try other values of N. I tested it for various N‘s, ranging from N = 200 to N = 3,000,000. The higher N, the smoother the curve, the stronger the patterns. It also occurs with some other peculiar choices for Ap, such as Ap = INT(p/2 + 1/2) or Ap= INT(p/3 + 1/2), but not in general, not even for Ap = INT(p/5 + 1/2).
It is surprising that the curve is so smooth, given the fact that we work with prime numbers, which behave somewhat chaotically. There has to be a mechanism that causes this unexpected smoothness. A mechanism that could be the key to proving the twin prime conjecture. More about this in section 2.
2. Connection to the Twin Prime Conjecture
If M = 6 SQRT(N) and Ap = INT(p/6 + 1/2), then the set S(M, N) defined in section 1, contains only elements q such that 6q – 1 and 6q + 1 are twin primes. This fact is easy to prove. It misses a few of the twin primes (the smaller ones) but this is not an issue since we need to prove that S(M, N), as N tends to infinity, contains infinitely many elements. The number of elements in S (M, N) is denoted as C(M, N).
Let us define R1(N) = R(M1, N) and R0(N) = R(M0, N). Here M1 = 6 SQRT(N) and M0 is defined in section 1, just below the plot. To prove the twin prime conjecture, one has to prove that R1(N) < R0(N) and that R0(N) does not grow too fast, as N tends to infinity.
The relationship R1(N) < R0(N) can be written as P(M1, N) / R0(N) < C(M1, N). If the number of twin primes is infinite, then C(M1, N) tends to infinity as N tends to infinity. Thus if P(M1, N) / R0(N) also tends to infinity, that is, if R0(N) / P(M1, N) tends to zero, then it would prove the twin prime conjecture. Note that P(M1, N) is asymptotically equivalent (up to a factor not depending on N) to N / (log M1)^2, that is, to N / (log N)^2. So if R0(N) grows more slowly than (say) N / (log N)^3, it would prove the twin prime conjecture. Empirical evidence suggests that R0(N) grows like log N at most, so it looks promising.
The big challenge here, to prove the twin prime conjecture, is that the observed patterns (found in section 1 and used in the above paragraph), however strong they are, may be very difficult to formally prove. Indeed, my argumentation still leaves open the possibility that there are only a finite number of twin primes: this could happen if R0(N) grows too fast.
The next step to make progress would be to look at small values of N, say N =100, and try to understand, from a theoretical point of view, what causes the observed patterns. Then try to generalize to any larger N hoping the patterns can be formally explained via a mathematical proof.
To receive a weekly digest of our new articles, subscribe to our newsletter, here.
About the author: Vincent Granville is a data science pioneer, mathematician, book author (Wiley), patent owner, former post-doc at Cambridge University, former VC-funded executive, with 20+ years of corporate experience including CNET, NBC, Visa, Wells Fargo, Microsoft, eBay. Vincent is also self-publisher at DataShaping.com, and founded and co-founded a few start-ups, including one with a successful exit (Data Science Central acquired by Tech Target). You can access Vincent’s articles and books, here.
Deep learning technology has become indispensable in the domain of modern machine interaction, search engines, and mobile applications. It has revolutionized modern technology by mimicking the human brain and enabling machines to possess independent reasoning. Although the concept of deep learning extends to a wide range of industries, the onus falls on software engineers and ML engineers to create actionable real-world implementations around those concepts. This is where the Feedforward Neural Network pitches in.
The simplified architecture of Feedforward Neural Networks presents useful advantages when employing neural networks individually to achieve moderation or cohesively to process larger, synthesized outputs.
Today, we’ll dive deep into the architecture of feedforward neural network and find out how it functions. So, let’s dive right in!
Feedforward Neural Networks are artificial neural networks where the node connections do not form a cycle. They are biologically inspired algorithms that have several neurons like units arranged in layers. The units in neural networks are connected and are called nodes. Data enters the network at the point of input, seeps through every layer before reaching the output. However, the connections differ in strength or weight. The weight of the connections provides vital information about a network.
Feedforward Neural Networks are also known as multi-layered networks of neurons (MLN). The neuron network is called feedforward as the information flows only in the forward direction in the network through the input nodes. There is no feedback connection so that the network output is fed back into the network without flowing out.
These networks are depicted through a combination of simple models, known as sigmoid neurons. The sigmoid neuron is the foundation for a feedforward neural network.
Here’s why feedforward networks have the edge over conventional models:
Conventional models such as Perceptron take factual inputs and render Boolean output only if the data can be linearly separated. This means the positive and negative points should be positioned at the two sides of the boundary.
The selection of the best decision to segregate the positive and the negative points is also relatively easier.
The output from the sigmoid neuron model is smoother than that of the perceptron.
Feedforward neural networks overcome the limitations of conventional models like perceptron to process non-linear data efficiently usingsigmoid neurons.
With convolutional neural networks and recurrent neural networks delivering cutting-edge performance in computer science, they are finding extensive use in a wide range of fields to solve complex decision-making problems.
The feedforward neural networks comprise the following components:
Input layer
Output layer
Hidden layer
Neuron weights
Neurons
Activation function
Input layer:This layer comprises neurons that receive the input and transfer them to the different layers in the network. The number of neurons in the input layer must be the same as the number of the features or attributes in the dataset.
Output layer:This layer is the forecasted feature that depends on the type of model being built.
Hidden layer:The hidden layers are positioned between the input and the output layer. The number of hidden layers depends on the type of model. Hidden layers have several neurons that impose transformations on the input before transferring. The weights in the network are constantly updated to make it easily predictable.
Neuron weights:The strength or the magnitude of connection between two neurons is called weights. The input weights can be compared just as coefficients in linear regression. The value of the weights is usually small and falls within the range of 0 to 1.
Neurons:The feedforward network has artificial neurons, which are an adaptation of biological neurons. Artificial neurons are the building blocks of the neural network. The neurons work in two ways: first, they determine the sum of the weighted inputs, and, second, they initiate an activation process to normalize the sum.
The activation function can be either linear or nonlinear. Weights are related to each input of the neuron. The network studies these weights during the learning phase.
Activation Function: This is the decision-making center at the neuron output. The neurons finalize linear or non-linear decisions based on the activation function. It prevents the enlargement of neuron outputs due to cascading effect because of passing through many layers. The three most important activation functions are sigmoid, Tanh, and Rectified Linear Unit ( ReLu).
Sigmoid:It maps the input values within the range of 0 to 1.
Tanh:It maps the input values between -1 and 1.
Rectified linear Unit: This function allows only the positive values to flow through. The negative values are mapped at 0.
Data travels through the neural network’s mesh. Each layer of the network acts as a filter and filters outliers and other known components, following which it generates the final output.
Step 1:A set of inputs enter the network through the input layer and are multiplied by their weights.
Step 2:Each value is added to receive a summation of the weighted inputs. If the sum value exceeds the specified limit ( usually 0), the output usually settles at 1. If the value falls short of the threshold ( specified limit), the result will be -1.
Step 3:A single-layer perceptron uses the concepts of machine learning for classification. It is a crucial model of a feedforward neural network.
Step 4:The outputs of the neural network can then be compared with their predicted values with the help of the delta rule, thereby facilitating the network to optimize its weights through training to obtain output values with better accuracy. This process of training and learning generates a gradient descent.
Step 5:In multi-layered networks, updating weights are analogous and more specifically defined as backpropagation. Here, each hidden layer is modified to stay in tune with the output value generated by the final layer.
The operation on this network can be divided into two phases:
First: Learning Phase
This is the first phase of the network operation, during which the weights in the network are adjusted. The weights are modified to make sure the output unit has the largest value.
The feedforward network uses a supervised learning algorithm that enhances the network to know not just the input pattern but also the category to which the pattern belongs. The pattern gets modified as it passes through other layers until the output layer. The units present in the output layer will be of different categories.
The output values will be compared with the ideal values of the pattern under the correct category. The output unit with the right category will have the largest value than the other units. The connection weights are modified according to this to make sure the unit with the correct category re-enters the network as the input. This is known as back-propagation.
The length of the learning phase depends on the size of the neural network, the number of patterns under observation, the number of epochs, tolerance level of the minimizer, and the computing time (that depends on the computer speed).
Second: Classification Phase
The weights of the network remain the same (fixed) during the classification phase. The input pattern will be modified in every layer till it lands on the output layer. The classification is done based on a selection of categories related to the output unit that has the largest value. The feedforward network must be selected along with a list of patterns to perform the classification process. The classification phase is much faster than the learning phase.
The simplified architecture of Feed Forward Neural Network offers leverage in machine learning.
A series of Feedforward networks can run independently with a slight intermediary to ensure moderation.
The network requires several neurons to carry out complicated tasks.
The handling and processing of non-linear data can be done easily with a neural network that is otherwise complex in perceptron and sigmoid neurons.
The excruciating decision boundary problem is alleviated in neural networks.
The architecture of the neural network can be of different types based on the data. For instance, a convolutional neural network (CNNs) has registered exceptional performance in image processing, whereas recurrent neural networks (RNNs) are highly optimized for text and voice processing.
Neural networks require massive computational and hardware performance for handling large datasets, and hence, they require graphics processing units (GPUs). Kaggle Notebooks and Google Collab Notebooks are two popular GPUs used extensively in the market.
Given that we’ve only scratched the surface of deep learning technology, it holds huge potential for innovation in the years to come. Naturally, the future scope of deep learning is very promising.
In fact, neural networks have gained prominence in recent years following the emerging role of Artificial Intelligence in various fields. Since deep learning models are capable of mimicking human reasoning abilities to overcome faults through exposure to real-life examples, they present a huge advantage in problem-solving and are witnessing growing demand.
From image and language processing applications to forecasting, speech and face recognition, language translation, and route detection, artificial neural networks are being used in various industries to solve complex problems.
Artificial intelligence is transforming life as we know it. The COVID-19 pandemic has further accelerated automation and increased enterprise investment in AI across the globe. The global AI market size is expected to grow to USD 309.6 billion by 2026, at a Compound Annual Growth Rate (CAGR) …. While there is greater adoption of AI worldwide, scaling AI projects is not easy. According to Gartner, the staff skills, the fear of the unknown, and finding a clear starting point for AI projects are some of the most prominent challenges faced by enterprises in their AI journey. To overcome these challenges and launch new AI initiatives, executives are setting up dedicated AI knowledge platforms or AI Center of Excellence (AI CoE) within their organization. As per a Harvard Business Review article, 37% of U.S. executives from large firms that use AI have already established a COE in AI.
What is an AI Center of Excellence (AI CoE)?
AnAI Center of Excellence(AI CoE) is a centralized knowledge group or team that guides and oversees the implementation of organization-wide AI projects. An AI CoE brings together the AI talent, knowledge, and resources required to enable AI-based transformation projects. It brings together all the AI capabilities needed to address the challenges of AI adoption and prioritize AI investments. AI COE essentially serves as an internal centralized counsel to identify new opportunities for leveraging AI to solve various business problems such as controlling costs, improve efficiency, and optimize revenue. The key objective of setting up an AI CoE is to build and support the AI vision of the company and serve as an internal counsel to manage all AI projects.
Why should you build an AI CoE?
An AI CoE plays a vital role in developing AI talent and driving innovation within the company. The team acts as an internal counsel for guiding the company on all AI initiatives from prioritizing AI investments to identifying high-value use cases for implementation. By providing a robust framework for AI implementation, the CoE helps in building future-ready engineering capabilities to manage high volumes of data, improve efficiency, and drive innovation. Here are the key benefits of creating an AI CoE:
To consolidate AI resources, learnings, and talent in one place.
To create and implement a unified AI vision and strategy for the business.
To standardize the platforms, processes, and approach to AI within the organization.
To speed up AI-led innovation and identify new revenue opportunities.
To scale data science efforts and make AI accessible to every function within the company.
To drive AI-enabled initiatives such as cost reduction, churn prevention, and revenue maximization to stay ahead of competitors.
How to build an AI CoE?
Technology is constantly evolving. Enterprises must continuously adapt their AI roadmap to deliver the highest business value. With scattered data science teams, resources, and legacy systems, it becomes hard to know where to start. To set up an AI innovation center, business leaders must take a holistic approach encompassing all the factors that contribute to its success.
1. Strategy: Strategy helps in clearly defining the business goals, identifying the high-impact use cases, and prioritizing the AI investments. When you are starting with AI, while it is okay to think big, it is wise to start with small and smart, achievable, realistic AI goals. This will allow you to progress quickly and gauge the ROI from the AI initiatives.
2. People: The people-oriented pillar helps define the data-driven culture and the strategies for managing the teams that use AI and data within the organization. It is important to clearly define the roles, data owners, and structures for driving AI-led innovation. The people strategy also helps in hiring the right AI talent and fostering a collaborating, innovation-driven culture.
3. Processes: The process-oriented pillar helps define the methods to sustain continual AI innovation within the company. The more iterative and agile the process is, the easier it is to learn fast and adapt to fast-changing business needs.
4. Technology: The right technology stack is crucial for building robust AI capabilities. The tech strategy should clearly define the process for evaluation, and adoption of new tools that match the organizational needs and work well with the existing IT infrastructure.
Best practices and tips to build an AI CoE
If executed with leadership commitment and a very well-planned strategy, AI has the power to reward organizations with non-linear rewards, however, if not operationalized with the right fundamentals and critical mass scale, it could become a bottomless pit of investments with no significant returns. Here are some best practices and tips to set up an AI CoE:
1. Set AI vision and measurable goals
Leaders need to identify the key business objectives they want to achieve with AI such as improving conversion, reducing churn, etc. These core goals help in prioritizing the AI investments to be made and in identifying the most high-impact use cases to be implemented first. You also need to develop a transparent and compressive system to track the progress and measure the benefits of their AI initiatives. By capturing the benchmarks and the KPIs for the AI experiments, enterprises can gauge the value generated and do course corrections early on if required.
2. Assemble the right team and set up governance
People are the core strength of an AI CoE. Once you have identified the business problems to solve, you need to onboard the right talent to the core innovation team. Roles and responsibilities will have to be clearly defined. Leaders will also have to set up governance to oversee the development of the CoE.
3. Get your data ready for AI
AI is only as smart as the data used to train it. Enterprises must invest in robust data collection, cleaning, storage, management, and validation mechanisms to ensure that the data used is reliable and ready for AI.
4. Standardize and create reusable AI assets
Based on the existing systems, the business objectives, and high-value AI use cases, companies must invest in the necessary tools and infrastructure required to apply AI. By creating scalable, flexible, and reusable AI assets, enterprises can apply their AI solutions to multiple scenarios and derive more value.
5. Democratize AI and collaborate with no-code platforms
Good ideas can come from anywhere. To drive AI-led innovation, you need a collaborative, data-driven work culture and the right AI tools. Ano-code AIplatform can enable anyone in the organization to use AI and apply their perspective to solve complex business problems. In addition to democratizing AI, these platforms help in standardizing AI operations within the company. Leaders must also initiate AI and data science education across functions to nurture an AI-first culture.
The final verdict
In today’s competitive market, AI has become a necessity and a key enabler for growth.No-code AI platformssuch as HyperSense can accelerate the adoption and democratization of AI across the organization. It puts the power of AI in the hands of the non-technical business user, eliminating the traditional challenges of misaligned objectives, skill shortage, and siloed operations.
Flexible and modular AI platforms play a vital role in broadening organization-wide AI adoption. A dedicated AI CoE and the rightAI platformcan facilitate the launch of AI initiatives, accelerate AI implementation, improve efficiencies, and ultimately help enterprises to achieve their long-term AI goals.
For more details on HyperSense AI platform, please email us at [email protected] or visit our website, www. hypersense.subex.com
Castaneda, Eduardo. Carl Sagan with the planets. 1981. Photograph.https://www.loc.gov/item/cosmos000104/. (Photo taken on the set of the TV show Cosmos.)
“The Metaverse” is a term appearing more and more in the tech press lately. Which begs the question, what does the term really mean? What does the concept actually imply from a feasibility standpoint? And most importantly, what are the prospects for something like a metaverse to appear and gain adoption?
The vision of a metaverse or mirrorworld
“The Metaverse” is a term coined by author Neal Stephenson for his 2003 bookSnow Crash. In the book, Stephenson presents the Metaverse as an alternate, more manipulable and explicitly informative virtual and augmented reality. That overlay provided a pervasive, interactive, digital complement to physical reality. The term gained popularity among tech enthusiasts beginning in the 2000s.
More recently, folks like Mark Zuckerberg have co-opted the term. According to Zuckerberg as quoted by Kyle Chayka ofThe New Yorker, “The metaverse is ‘a virtual environment where you can be present with people in digital spaces. It’s ‘an embodied Internet that you’re inside of rather than just looking at. We believe that this is going to be the successor to the mobile Internet.’”https://www.newyorker.com/culture/infinite-scroll/facebook-wants-us-to-live-in-the-metaverse
Facebook clearly hopes to expand the market for its Oculus goggles and its advertising, and is using the metaverse metaphor to help describe to its users how they might shop, game and interact more immersively online. It’s a narrow, frankly self-serving view of what a metaverse might consist of.
Since Stephenson’s book was published, other terms have cropped up that describe a comparable concept. Kevin Kelly, for example, introduced his concept of a “Mirrorworld” (a term hardly original to him) in an article inWiredmagazine in March 2019.
In a discussion withForbescontributor Charlie Fink onstage at Augmented World Expo in August 2019, Kelly said,“Mirrorworld is a one-to-one map of the real world that’s in digital form. That is, there’s a digital skin right over the real world that can be revealed using AR. It’s at the same scale and in the same place, so it’s a skin. Or you could say it’s a ghost or it’s embedded in the same way.”https://arinsider.co/2019/08/02/xr-talks-what-on-earth-is-mirrorworld/
During the discussion, Kelly and Fink both agreed that it could well take 25 years for the Mirrorworld to fully emerge as a commonly useful and scaled out “digital skin.”
Digital twins imagined
More explicitly, Kelly and Fink were really talking about the presentation layer or digital skin as 3D representations of people, places, things and concepts, and how they interact. Fink previously used the term metaverse in a similar context a year earlier. Either the mirrorworld or the metaverse, in other words, starts with interacting, interoperable representations known as digital twins (a term often used by academic MIchael Grieves beginning in 2002 in a product lifecycle manufacturing context).
At present, useful digital twins behave in limited, purpose-specific ways like the physical objects they represent. Manufacturers–GE, Schneider Electric and Siemens, for example–create digital twins of equipment such as gas turbines designed for use in power plants to predict failures at various points in each product’s lifecycle. Those twins help the manufacturers refine those designs.
But the longer-term vision is more expansive. All of these companies also have promising, but still nascent, initiatives in the works that could potentially expand and further connect digital twins in use. Consider, for instance, Siemens’ concept–at least four years old now–for an industrial knowledge graph that could empower many digital twins with relationship-rich, contextualizing data:
Some organizations envision even larger and more intricately interactive and useful aggregations of digital twins. The UK’s Centre for Digital Built Britain(CDBB), for instance, imagines “the entire built environment as an interconnected system if digital twins are developed to be interoperable, secure and connected.”
Digital models of government agencies, when up and running, could conceivably be interconnected as a combination of models to provide views of past, present and future states of how these agencies interact in different contexts. For their part, asset-intensive industries such as pharmaceuticals, consumer products, transportation and agriculture are all working toward whole supply chain digitization.
Unfortunately, most data and knowledge management shops are not versed in the kind of web scale data management the UK’s CDBB hopes to harness for these organization-sized digital twins. Nor do they have the authority or the budget to scale out their capabilities.
The Data (and Logic) Challenges of Interactive Virtual and Augmented Things
Stephenson, Kelly, and Fink’s visions are inspiring, but they are mainly imagining the possible from the perspective of users, without exploring the depths of the challenges organizations face to make even standalone twins of components of the vision a reality.
What has this meant to the typical information-intensive enterprise? A mountain of 10,000+ databases to manage, thousands of SaaS and other subscriptions to oversee, custom code and many operating systems, tools, and services to oversee. All of these are spread across multiple clouds and controlled by de facto data cartels, each of which claims control based on its role in purposing the data early on in the provenance of that data.
Despite long-term trends that have helped with logic and data sharing such as current and future generations of the web, data is now more balkanized than ever, and the complexity is spiraling out of control.
The truth is, most of this out-of-control legacy + outsourced, application-centric cloud stack gets in the way of what we’re trying to do in a data-centric fashion with the help of knowledge graphs and a decentralized web.
Getting beyond data silos and code sprawl to a shared data and logic foundation
As you can imagine, moving beyond an entrenched paradigm that schools have been reinforcing for 40 years requires stepping back and rethinking how the “digital ecosystem”, such as it is, needs to be approached with a more critical eye. For starters, claims of automated data integration that are everywhere need to be considered with a grain of salt. The truth is, data agreement is hard, data integration is even harder, and interoperability is the hardest. And there are no interactive digital twins without interoperability.
So there are tiers of difficulty the data and knowledge science community has to confront. Predictably, the more capability needed, the more care and nurturing a knowledge foundation requires. In simple terms, the tiers can be compared and contrasted as follows:
Agreement. Compatibility with and consistency of two or more entities or datasets
Integration. Consolidation within a single datasetthat provides broad data access and delivery
Interoperability. Real-time data exchange and interpretation between different systems that share a common language. This exchange and interpretation happens in a way that preserves the originating context of that data.
In Part II, I’ll delve more into the knowledge foundation that will be necessary for a shared metaverse or mirrorworld to exist.
The Healthcare sector is among the largest and most critical service sectors, globally. Recent events like the Covid-19 pandemic have furthered the challenge to handle medical emergencies with contemplative capacity and infrastructure. Within the healthcare domain, healthcare equipment supply and usage have come under sharp focus during the pandemic. The sector continues to grow at a fast pace and will record a 20.1% CAGR of surge; plus, it is estimated to surpass $662 billion by 2026.
Countries like the US spend a major chunk of their GDP on healthcare. The sector is technologically advanced and futuristic and the amount spent per person annually is higher in comparison to any other country in the world. There are general acute care hospitals, government hospitals, specialty, non-profit, and privately owned hospitals as well. Healthcare funding includes private, governmental, and public insurance claims and finance processes. The US private healthcare is dominated by private medicare facilities, in which the costs are borne by the patients majorly.
Underlying challenges in the sector’s digital transformation
The Healthcare sector has its challenges to deal with. Depending on legacy apps and following conventional procedures for treating patients has resulted in a lot of revenue losses. Hospital revenues have taken a setback and even though the EHR (electronic health record) system is implemented yet granular information in a physician’s clinical summary is often difficult to record and maintain.
Then, the medical billing and claim procedure is yet another tough turf to manage. On part of the healthcare institutions, maintaining a seamless patient experience has become crucial. Additionally, the process of translating a patient’s medical details and history into coding allows healthcare institutions and payers to track and monitor a patient’s medical current condition, manage history and update correct records. The process is lengthy and the slightest human error can result in discrepancies in the patient’s history and financial transactions for the treatment received. It can further disrupt the claims and disbursal process for all future transactions, posing risk to tracking a patient’s current medical condition. Not merely this, it can create additional hassles for medical practitioners, healthcare institutions, and insurance providers to process and settle claims.
Moreover, in terms of tracking and providing appropriate treatment, health practitioners and institutions, on the other hand, are faced with the persistent challenge of collating patient’s data from multiple sources and analyzing it manually.
Building medical ai models with reliable training dataset
The healthcare sector deals with gigantic data, that is sensitive to patient’s health and also impacts physician’s credibility.
For a long time, health institutions have invested significantly in managing patient records and relied on software and costly legacy applications, which have their own limitations. Meanwhile, hiring of trained professionals or medical coders and outsourcing of service platforms have always added to the spending. Implementation of EHR systems has improved the fundamental processes yet, the technical limitations have made it difficult for the medical sector to rely on them, entirely. This has led to delays in accessing patients’ treatment history, suggesting effective treatment & care, billing, and processing of medical claims; eventually, hurting revenue growth for the health institutions and other players in the chain.
To handle all such scenarios, the healthcare community has aggressively adopted Artificial Intelligence enabled with machine learning with NLP for automation of key processes. AI and machine learning programs are automating procedures like medical coding and reducing the cycle of patient care. In more than 100 countries the clinical summaries are converted into codes. AI and NLP or natural language processing-based programs trained with structured medical training data are helping doctors access patient’s history based on the medical codes, instantly without delay. The effectiveness of AI-based results are reducing patient visits, stress on the doctors, and improving the entire lifecycle of patient experience with doctors, health service providers, and medical claim payers.
In addition to this, the AI-enabled processes are also easing out the pressure on all the stakeholders in the loop, with tasks like revealing out-of-pocket expenses to patients before availing of the healthcare services. This has helped patients plan their expenditure, beforehand. It has also eased out pre-authorization procedures and fastened the entire cycle of patient care by the healthcare provider. Firms like Cogito are actively developing medical coding and billing training data with the help of a specialized team of in-house medical practitioners to deliver cutting-edge data labeling services. In terms of medical billing, AI programs powered with machine learning and structured training data are ensuring efficient revenue cycles and preventing the claim denials based on incorrect or missing information of the patient.
Endnote:
Recent AI implementations have helped healthcare institutions provide proactive support to patients and tackle significant revenue loss, in the process. For the healthcare domain, Artificial Intelligence is letting patients claim payers, and healthcare service providers work in tandem, accelerating overall sectoral growth. AI-led automation powered with NLP is saving time and costs up to 70%; including overall costs. From availing a health service to identifying the right health institution for treatment, both patients and doctors are gaining immense value from the transformation. Originally Published at – Healthcare document processing
