Month: October 2021

In the past, Natural Language Processing (NLP) models struggled to differentiate words based on context due to the use of shallow embedding methods for text analysis.

Bidirectional Encoder Representations for Transformers (BERT) has revolutionized the NLP research space. It excels at handling language problems considered to be “context-heavy” by attempting to map vectors onto words post reading the entire sentence in contrast to traditional methods in NLP models.

This blog sheds light on the term BERT by explaining its components.

BERT (Bidirectional Encoder Representation from Transformers)

Bidirectional – Reads text from both the directions. As opposed to the directional models, which read the text input sequentially (left-to-right or right-to-left), the Transformer encoder reads the entire sequence of words at once. Therefore, it is considered bidirectional, though it would be more accurate to call it non-directional.

Encoder – Encodes the text in a format that the model can understand. It maps an input sequence of symbol representations to a sequence of continuous representations. It is composed of a stack with 6 identical layers. Each layer has two sub-layers. The first layer is a multi-head self-attention mechanism. And the second layer is a simple, position-wise fully connected feed-forward network. We employ a residual connection around each of the two sub-layers, followed by Layer Normalization. The key feature of layer normalization is that it normalizes the inputs across the features.

Representation – To handle a variety of down-stream tasks, our input representation can unambiguously represent both a single sentence and a pair of sentences, e.g. Question & Answering, in one token sequence in the form of transformer representations.

Transformers – Transformer includes two separate mechanisms — an encoder that reads the text input and a decoder that produces a prediction for the task. Since BERT’s goal is to generate a language model, only the encoder mechanism is necessary.

Transformers are a combination of 3 things:

In this blog, we will only talk about the Attention Mechanism.

Limitations of RNNs over transformers:

• RNNs and its derivatives are sequential, which contrasts with one of the main benefits of a GPU i.e. parallel processing
• LSTM, GRU and derivatives can learn a lot of long-term information, but they can only remember sequences of 100s, not 1000s or 10,000s and above

Attention Concept

As you can see in the image above, attention must be paid at the stop sign. And for the text, eating (verb) has higher attention in relation to oats.

Transformers use attention mechanisms to gather information about the relevant context of a given word, then encode that context in the vector that represents the word. Thus, attention and transformers together form smarter representations.

Types of Attention:

1. Self-Attention
2. Scaled Dot-Product Attention
3. Multi-Head Attention

Self-Attention

Self-attention, also called intra-attention is an attention mechanism that links different positions of a single sequence to compute a representation of the sequence. Self-attention has been used successfully in a variety of tasks including reading comprehension, abstractive summarization, etc.

Scaled Dot-Product Attention

Scaled Dot-Product Attention consists of queries Q and keys K of dimension dk, and values V of dimension dv. We compute the dot products of the query with all keys, divide each of them by √dk, and apply a SoftMax function to obtain the weights on the values.

The two most commonly used attention functions are:

• Dot-product (multiplicative) attention: This is identical to the algorithm, except for the scaling factor of √1dk.
• Additive attention: Computes the compatibility function using a feed-forward network with a single hidden layer.

While the two are similar in theoretical complexity, dot-product attention is much faster and more space-efficient in practice as it uses a highly optimized matrix multiplication code.

Multi-Head Attention

Instead of performing a single attention function with dmodel dimensional keys, values and queries, it is beneficial to linearly project the queries and values h times with different, trained linear projections to dk, dk and dv dimensions, respectively. We can then perform the attention function in parallel to each of these projected versions, yielding dv-dimensional output values. These are concatenated and once again projected, resulting in the final values. Multi-head attention allows the model to jointly attend to information from different representation subspaces at different positions.

Applications of BERT

1. Context-based Question Answering: It is the task of finding an answer to a question over a given context (e.g., a paragraph from Wikipedia), where the answer to each question is a segment of the context.
2. Named Entity Recognition (NER): It is the task of tagging entities in text with their corresponding type.
3. Natural Language Inference: Natural language inference is the task of determining whether a “hypothesis” is true (entailment), false (contradiction), or undetermined (neutral) given a “premise”.
4. Text Classification

Conclusion:

Recent experimental improvements due to transfer learning with language models have demonstrated that rich and unsupervised pre-training is an integral part of most language understanding systems. It is in our interest to

further generalize these findings to deep bidirectional architectures, allowing the same pre-trained model to successfully tackle a broader set of NLP tasks.

References:

1. https://arxiv.org/abs/1810.04805
2. https://arxiv.org/abs/1706.03762

Do you use Google Services on your mobile phones? If so, you would have probably noticed that the predictive capability of this service has recently improved with respect to speed and accuracy. The enhanced predictive capability of Google is now faster, thanks to TensorFlow Lite working with your phone’s GPU.

What is TensorFlow Lite?

TFLite is TensorFlow’s light weight solution for mobile, embedded and other IoT devices. It can be described as a toolkit that helps developers run the TensorFlow model on such devices.

What is the need for TensorFlow Lite? Running Machine Learning models on mobile devices are not easy due to the limitation of resources like memory, power, storage, etc. Ensuring that the deployed AI models are optimized for performance under such constraints becomes a necessary step in such scenarios. This is where the TFLite comes into the picture. TFLite models are hyper-optimized with model pruning and quantization to ensure accuracy for a small binary size with low latency, allowing them to overcome limitations and operate efficiently on such devices.

TensorFlow Lite consists of two main components:

• The TensorFlow Lite converter: that converts TensorFlow models into an efficient form and creates optimizations to improve binary size and performance.
• The TensorFlow Lite interpreter: runs the optimized models on different types of hardware, including mobile phones, embedded Linux devices, and microcontrollers.

TensorFlow Lite Under the Hood

Before deploying the model on any platform, the trained model needs to go through a conversion process. The diagram below depicts the standard flow for deploying a model using TensorFlow Lite.

Fig: TensorFlow Lite conversion and inference flow diagram.

Step 1: Train the model in TensorFlow with any API, for e.g. Keras. Save the model (h5, hdf5, etc.)

Step 2: Once the trained model has been saved, convert it into a TFLite flat buffer using the TFLite converter. A Flat buffer, a.k.a. TFLite model is a special serialized format optimized for performance. The TFLite model is saved as a file with the extension .tflite

Step 3: Post converting the TFLite flat buffer from the trained model, it can be deployed to mobile or other embedded devices. Once the TFLite model gets loaded by the interpreter on a mobile platform, we can go ahead and perform inferences using the model.

Converting your trained model (‘my_model.h5’) into a TFLite model (‘my_model.tflite’) can be done with just a few lines of code as shown below:

How does TFLite overcome these challenges?

TensorFlow Lite uses a popular technique called Quantization. Quantization is a type of optimization technique that constrains an input from a large set of values (such as the real numbers) to a discrete set (such as the integers). Quantization essentially reduces the precision representation of a model. For instance, in a typical deep neural network, all the weights and activation outputs are represented by a 32-bit floating-point numbers. Quantization converts the representation to the nearest 8-bit integers. And by doing so, the overall memory requirement for the model reduces drastically which makes it ideal for deployment in mobile devices. While these 8-bit representations can be less precise, certain techniques can be applied to ensure that the inference accuracy of the new quantized model is not affected significantly. This means that quantization can be used to

make models smaller and faster without sacrificing accuracy. Stay tuned for the follow up blog that will be a walkthrough of how to run a Deep learning model on a Raspberry Pi 4. In the meantime, you can keep track of all the latest additions to TensorFlow Lite at https://www.tensorflow.org/lite/

Robotic Process Automation as we know it today is a framework through which large scale processes can be automated. The biggest advantage of current RPA systems is that they can be easily integrated with current IT and Software systems.

RPA can be used to automate repetitive process-driven work with well-defined outcomes. However, there is a catch. If this is Process Automation, then why don’t we just call it Process Automation? Apart from the marketing angle of using the word Robotic in Process Automation, whoever coined the term had something beyond just process automation in mind.

The intent and endeavor to automate workflows are not new. In traditional systems, automation was achieved by software developers building a comprehensive list of APIs or Scripts to cover all pre-conceived and possible tasks. However, there was a serious drawback in this approach, it was not scalable.

In modern RPA systems, instead of writing a finite number of scripts, the software systems trained to understand any number of steps as executed by recording the actual process and then replicating the same as it was recorded with the RPA platform. The 90’s generation that used excel extensively to write macros to record a set of standard activities and then store it so that every time those set of processes are run, it executes a complex but well-defined set of processes in a certain sequence. This was also called an excel macro. The current RPA platforms execute on similar principles, although at a much larger scale of complexity and size with advanced technology.

While this overcomes the problem of scale, there was still one last challenge. The significance of the word Robotic comes from the fact that there is an element of intelligence expected from the process of automation undertaken by an RPA platform. This intelligence allows the platform to take autonomous decisions based on

trigger. While the trigger can be programmed, the same is not the case with the decision tree that activates the trigger.

Most RPA software’s like UIPath, Blue Prism and Automation Anywhere have so far come out with platforms that are very good at process automation by being programmed to follow a certain set of standard processes. However, they fall short miserably when it comes to making the whole process intelligent. They fail to transcend from their platforms being Automatic to Autonomous.

Let’s illustrate this with an example. Let’s assume there is a complex senior management report that gets generated by collating some specific lines of data from various enterprise databases like Oracle, SAP, and others. After the report generation, an automated mail is sent out to 500 users with specific content to each user.

The process is repetitive because multiple reports need to be generated from multiple sources of data. This is a complex process with ginormous scales of data having a multiplier effect on each of the customized reports generated for more than 500 stakeholders which are then emailed to intended recipients.

Sounds like quite a complex process but today’s RPA platforms are equipped to handle this easily and repeat process automation with minimum errors. This does not require a lot of development on existing RPA platforms. As mentioned, it can also be easily integrated into multiple platforms mentioned earlier.

However, current implementations still fall short of one critical feature required to certify it as a true autonomous implementation.

Taking one particular use case as an example, if the RPA platform had to decide on whom to send the reports based on some critical random content of the reports which could be either a picture, text or numeric and it could appear in a random pattern, the platform would fail to do so. It will fail for the simple reason that it does not know how to detect and tackle unknown situations and the decisions thereof because it is not a part of the standard process.

Similarly, many other use cases are missing from current RPA platforms. While they claim that some of them are AI-enabled, most of them are not there yet.

The main reason for such a shortcoming is that AI is not the core of process automation developers. Naturally, it is an area they are skeptical in investing and rightfully so. It is going to be difficult for them to develop such a specialized competency. The RPA platforms should, therefore, drop the word Robotic unless their platforms are truly autonomous.

The RPA enterprise customers who see a real and large-scale implementation of their process automation platforms should work with AI service providers like Affine, to be able to add the element of intelligence and true autonomous Capabilities to the process automation already implemented.

One should not have the apprehensions of integration here because just like RPA platforms can be easily integrated into existing systems, AI modules can also be integrated into either RPA modules or to the end systems directly.

That is when RPA implementations will truly become Robotic in nature.

1. A quick introduction to Convolution Neural Networks

The field of computer vision has witnessed a paradigm shift after the introduction of Convolutional Neural Network (CNN) architectures which has pushed AI performance at par with humans. There has been significant progress in CNN driven architectures right from the first AlexNet architecture published in 2012 to newer architectures like ResNet, DenseNet, NASNet and more recently EfficientNet; each focusing on improving accuracy while rationalizing the computing cost of adoption (through a lesser number of parameters).

An Illustration of CNN architecture

Evolution of various CNN architectures Ref: https://arxiv.org/pdf/1905.11946.pdf

CNNs learn faster with higher accuracy than any traditional non-convolutional image models owing to features like :

• Local connectivity: While this limits the learnings to nearby pixel but it is sufficient enough to learn correlations required to evaluate an image
• Parameter sharing across spatial locations: It makes learning easier and faster by reducing redundancy. e.g. if the algorithm has learned to detect horizontal edge at a point A, it need not learn horizontal edge detection again at point B

2. Drawbacks of CNN

While CNN has worked remarkably well, they fall short on 2 key aspects: Lack of Invariance: Human beings perceive in a translation invariance way, which means we are capable of identifying an object even if the location and orientation of the object changes in our field of view. An example below:

Humans can identify cat in each of the above scenarios. However, CNN needs to be trained on multiple orientation scenarios for accurate inferencing. While image augmentation techniques have helped to overcome the orientation challenge, but it leads to higher processing, data management costs and also might not work in all scenarios.

Loss of information on related features: Image Source

In the scenario above, CNN will recognize both Figures A and B as a face.

This happens due to the Pooling layers in the CNN architecture. In simple terms, we know that initial layers in CNN learn about the low-level features e.g. edges, points, curves, arcs, etc., while the later layers learn about high-level features e.g. eyes, nose, lips which are further enhanced to identify the actual object i.e. the human face in subsequent layers. The intermediate Pooling layers help in regulating these high order features while reducing the spatial size of the data flowing through the network. The dynamics of Pooling layers don’t take into account the spatial relationships between simple and complex objects.

Thus, in both Figure A and B, CNN recognizes a face by evaluating the presence of high-level features like eyes, nose, lips, without applying any cognizance to their spatial relationships.

3. How can Capsule Network address the problem?

According to Hinton, for accurate image classification CNN should be able to learn and preserve the spatial relationships and hierarchies between the features. Capsule networks, introduced by Hinton and his team, is a step towards learning a better and complete knowledge representation.

What is a capsule? A capsule is a group of neurons that captures both the likelihood and parameters of the specific feature Capsule networks use a vector representation as compared to scalar representations used in existing neurons in CNN architectures. This capsule vector representation includes (1) whether an object exists (2) what are the key features (3) where is it located. Thus, for an object capsule, the activations will consist of: 1. Presence probability ak 2. Feature vector ck 3. Pose matrix OVk which represents the geometrical relationship between the object and its parts thus able to infer various feature orientations and hierarchies

Capsule networks will also be able to identify abstract version of the objects even if it has not been trained on the particular image, an example below:

Capsule networks will be able to identify Image2 with moderate accuracy even if it hasn’t been part of its training image. This is not possible with the regular CNN architectures.

4. What is the current status in Capsule Networks research?

Few popular techniques for implementing a capsule architecture has been discussed below:

A. Dynamic Routing Algorithm (source)

The original Capsules network developed by Hinton and his team uses a Dynamic routing algorithm to group child capsules to form a parent capsule. The vectors of an input capsule are transformed to match the output, and if a close match is available it forms a vote, capsules with a similar vote are grouped.

If the activity vector has a close similarity with the prediction vector, then both capsules are inferred to be related to each other. The main drawback of this approach is that it takes a long time both during training and inferencing of the model. Since the voting is done iteratively, each part could start by initially disagreeing and voting on different objects, before converging to the relevant object. Hence this iterative manner of voting is highly time consuming and inefficient

B. Stacked Capsule Autoencoders (SCAE) (source)

Dynamic routing can be thought of a bottom-up approach where the parts are used to learn parts à object relationship. Since this relationship is learnt in an iterative manner (iterative routing) it leads to many inefficiencies. SCAE takes a top-down approach where parts of a given object are predicted, thus removing the dependency of the iterative routing approach. A further advantage of this version of capsules is that it can perform unsupervised learning.

SCAE consists of two networks

1. 1. Part Capsule Autoencoder (PCAE) : Detects parts and recombines them into an image in the following manner

• Part Capsule Encoder: Segments an image into constituent parts, infers their poses
• Part Capsule Decoder: Learns an image template for each part and reconstructs each image pixel

2. Object Capsule Autoencoder (OCAE), organizes parts into objects

• Object Capsule Encoder: Tries to organize discovered parts and their poses into a smaller set of objects
• Object Capsule Decoder: Make predictions for each object part into one of the object types

Capsule Networks has achieved better performance as compared to CNN networks on MNIST (98.5% to 99%) and SVHN datasets (55% to 67%). The major drawback of SCAE is that the part decoder uses fixed templates, which are insufficient to model complicated real-world images. These networks can be perceived as a network with reasoning ability and thus with more expressive templates in the future, it can help infer complex real-world images efficiently with lesser data.

During the seventh match of the ongoing 12th season of the Indian Premier League between Royal Challengers Bangalore and Mumbai Indians at Bengaluru, Mumbai Indians defeated Royal Challengers Bangalore by 6 runs to register first win in IPL 2019.

In what was a nerve-wrenching match, it went down to the last ball. It was legendary batsman AB de Villiers who brought down the equation from 40 off 18 to 17 off the last over. Needing seven runs on the last ball, veteran bowler Lasith Malinga managed to win the match. However, once the match got over, replays confirmed that Malinga had bowled a front foot no-ball. With the umpire missing the same, there were some unhappy faces in the Bangalore camp.

“If this (the Malinga no-ball) had happened in the first, second or third overs of the game, I can tell you 100% surely that the umpire would have called it. The soil on the pitch becomes loose after a few overs. The line tends to go off even if it’s re-drawn. It’s too tough for the umpires to call no balls towards the end of the games. On a loose turf, when the bowler keeps landing on the pitch, the line doesn’t stay. From side view, we’ll see the line because it’s a two-dimensional image, and sometimes the lines are clearer outside the turf so the viewer thinks it’s there. There will be a parallax error.” – Says Hariharan, Former ICC Veteran Umpire

Cricket is a worldwide popular game where a single delivery can change the fate of the game. Every delivery is counted as a crucial moment for both teams. Umpires make the decisions regarding a no ball. Different technologies are being used to help the umpires to take their decisions. But often due to human perception, deciding whether a bowled delivery is a no ball or legal ball makes controversies. So, it is very important to make an accurate decision regarding a no ball Simultaneously, with advent and advances in Artificial Intelligence and Computer Vision, application of these two in different domains has become an emerging trend. Applying several computer vision techniques in analysing different Cricket events and automatically coming into decisions has become popular in recent days.

we have deployed a CNN based classification method with Resnet50 in order to automatically detect and differentiate foot overstepping no balls with fair balls. Our goal is to measure the probability of an image either it is a no-ball or not, to make the automated umpiring system and to eliminate the shortcoming of human perception.

Transfer learning uses the knowledge gained from solving one problem and apply it to another related problem. Facing the problem of collecting enough training data to rebuild models, transfer learning aims to transfer knowledge from a large dataset known as source domain to a smaller dataset named target domain. Either the feature spaces between domain data are different or the source tasks and the target tasks focus on different topics, boosting the performance of the target task.

Using the state-of-the-art deep learning techniques, we have devised a methodology to achieve our goal –

In our model to classify no-ball, we use images as input. Our input dataset contains images collected from google image search. The images are manually annotated and contain two classes: no ball and legal ball. We have used Keras and Tensorflow to build our model and generate results. Our model produces a score for both possible outcomes then each of them is converted to a probability by SoftMax.

All the collected images were resized, and the resolution of the images were enhanced using the techniques given below and were processed into the customized data augmentation pipeline. Some of the techniques used to enhance resolution of the image:
A] Contrast Limited Histogram Equalization (CLAHE)
B] Enhancing resolution of image using super resolution (OpenCV)

We have used Resnet50 as the classifying CNN as our model. In this step, we should keep the parameters of the previous layer, then remove the final layer and input our dataset to retrain the new last layer. The last layer of the model is trained by back propagation algorithm, and the cross-entropy cost function is used to synthesize the weight parameter by calculating the error between the output of the SoftMax layer and the label vector of the given test category.

To improve our results further we have used differential learning rates for the model layers. In the pretrained model, the layers closer to the input are more likely to have learned more general features. Thus, we don’t want to change them much. For these early layers, we set the LR to be very low. We increase the LR per layer gradually as we move deeper into the model.

To make the classification more robust and accurate we have used test time augmentation (TTA). Test Time Augmentation is to perform random modifications to the test images. Thus, instead of showing the regular, “clean” images, only once to the trained model, we will show it the augmented images several times. We will then average the predictions of each corresponding image and take that as our final prediction. This boost the results of the model at the testing time.

Using this model, we eliminated the shortcoming of Umpire’s perception to decide a overstep no-ball. Corresponding to many no ball detection approaches and applications, our approach is more effective and efficient.

References:

• https://www.icc-cricket.com/about/cricket/rules-and-regulations/decision-review-system
• https://ieeexplore.ieee.org/document/7873086
• https://ieeexplore.ieee.org/document/6968381

Many companies, especially those in BFSI and Legal sectors, deal with a large volume of handwritten and scanned documents. It is difficult to easily use the granular information in these documents to perform an analysis or even browse through the documents in a convenient manner. A simple classification of the documents into meaningful bins or folders would make it a lot easier to leverage the information within the documents.

The current blog focusses on a Document/Text Classification solution that we developed for an Insurance industry client which focussed on grouping medical/health insurance claims into pre-defined categories. The current process of categorization was done manually by a panel of experts. These experts had their own biasness and heuristics, which lead to inconsistencies.

We developed a Deep Learning based framework which ensembled learnings from document’s layout and structure, the content/text within a given document and amalgamation of consistent & coherent expert opinions. The framework helped in automation of the existing process leading to better efficiency and efficacy.

We had a set of 40k scanned images of medical insurance documents and tried building an algorithm to classify those documents into given 5 categories. These scanned documents exhibited characteristics for each of the classes based on the document structure and token sequences present in the document.

Document Sample:

Sample Image Features: Document Structure e.g. QR Code on Top Left Corner, Gridlines etc.

Sample Text Features: Presence of text sequences such as Health Claim Insurance Form, Field information e.g. Insured’s ID Number, Patient’s Name, Patient’s Address, Date of Service etc.

ANALYTICAL APPROACH

Over the past few years, Deep Learning (DL) architectures and algorithms have made impressive advances in fields such as image recognition and speech processing.

Their application to Natural Language Processing (NLP) has now proven to make significant contributions, yielding state-of-the-art results for some common NLP tasks. Named entity recognition (NER), topic modelling and sentiment analysis are some of the problems where neural network models have outperformed traditional approaches.
Convolutional neural networks (CNN) have also been widely used in automatic image classification systems, Object Detection and Recognition, Neural Style Transfer and many more applications. Image classification is the task of taking an input image and outputting a class or a probability of classes that best describes the image.

For the given problem, we decided to use the features of images as well as text in the document. Since these documents were scanned images, the first challenge was to extract text out of them, and second to draw meaningful insights from this text and image. Following is the overall solution architecture:

To extract the text sequences out of these images we performed OCR (Optical Character Recognition) using Tesseract. For python users, there is an OCR Library called “pytesseract” with the functionality of “image_to_string” conversion.

CHOICE OF MODEL

Through OCR steps we were able to extract the text sequences out of these scanned images. This leads us to achieve both text and image-based features which were leveraged for developing the classification algorithm.

Bi-directional LSTM:

For text features such as ‘Patient’s Name’, ‘Patient’s Address’, ‘Insured’s ID Number’, ‘Type of Bill’, ‘Patient’s Control Number’ etc. we decided to implement a bidirectional LSTM. Bidirectional LSTMs are an extension of traditional LSTMs that can improve model performance on sequence classification problems. It involves duplicating the first recurrent layer in the network so that there are now two layers side-by-side, then providing the input sequence as-is as input to the first layer and providing a reversed copy of the input sequence to the second.

The text sequences were converted into word vectors using pre-trained Glove embedding vector matrix and then passed through bidirectional LSTM (Long Short-Term Memory) Layer and 2 Dense Layers with ‘ReLU’ and ‘Softmax’ activations respectively.

Convolutional Neural Networks:

To deal with the image features we decided to implement a Convolutional Neural Network.
The image features were extracted and enhanced through 2Convolution layers and 3 dense layers with ReLU activations and softmax for the output layer activations respectively. Data Augmentation was done by flipping these scanned images for adding more features for robustness. Various transformations like resizing, rescaling etc. were also experimented with.

Combination of LSTM & CNN:

A combination of both LSTM and Convolution layers has also experimented on the text features, which resulted in a good classification accuracy.

Ensembling: Ensembling was done to capture features from different models and improve the accuracy of classification. This helped achieve 90% plus overall accuracy in correctly classifying the documents into respective 5 classes.

Please feel free to comment in case of any queries.

Contributors

Shifu Jain: Shifu is a Senior Business Analyst and a part of Affine Artificial Intelligence CoE “AICoE”. Her interests involve exploring and learning new researches in NLP, Topic Modelling, Recurrent Neural Networks etc.

Karthik Devaraj: Karthik is a Consultant at Affine with 6+ years’ experience in the field of Computer Vision, Machine Translation, Generative Algorithms.

Banking is re-inventing itself as it always has

“Help us build the kind of bank you want to use” – That’s what Monzo says to its customers. Monzo is a UK based banking app with no usage fees, no branches, no mortgages and zero charges for spending abroad. While few of the banks in the UK might have a similar offer, but where Monzo has gained grounds is how it emotionally connects to its users. It auto-budgets your expenses, highlights where you are spending more, helps in finding the best deal e.g. it puts the money in the best savings accounts. They have formed a partnership with Google and Amazon to ensure real-time banking. For generations of users who spend a considerable amount of their time on their smartphones, it’s more than a conventional bank. Not surprising, they are termed as the new “wonder kid” in the banking industry and are aiming to have a billion-user base in next 5 years (ref: www.thegaurdian.com).

Seems like a fiction isn’t it. Not quite, because innovation has been the constant change in the Banking sector. History presents us numerous pieces of evidence in the form of

• Giovanni di Medici setting up first credit banking systems in Renaissance Europe where charging interests was considered as a sin
• The Dutch East India company trading in Tulips as stocks
• The bond markets fueling the Rothschild to become one of the richest and influential family
• The evolution of e-Wallets, UPIs, e-Money transfers giving a new definition to funds re-allocation

While the initial transitions required a couple centuries, the later took few decades. The rate at which better technologies and techniques are being made available, innovations are hitting us at a faster pace than previously imagined. The change is already here to be seen

• From physical branch-based model to mobile platforms
• Human interactions with virtual interface like chat-bots/virtual assistants
• Single player bank to multiple players who are traditionally not banks e.g. blockchain
• Inclusion of social risks along with traditional-risk analysis
• Mass market products to hyper-personalized products in real time

With Fintech startups gaining greater prominence and technology behemoths such as Facebook, Amazon possessing in-direct challenges to the traditional banking systems, competition in this sector is going to get more serious. In the Indian context, with non-traditional players like PayTM and Reliance making in-roads, the baking landscape might undergo a complete transformation.

Why is it happening now and what changed?

Two key factors – Creation and Consumption. While “Creation” is being driven by mining better insights through “data democratization” enabled on Big Data platforms, the “Consumption” has increased through relevant and accurate outcomes on these data catalyzed through “Machine Learning and more recently Artificial Intelligence”.

Artificial Intelligence(AI) has accelerated the rate of innovations in the last couple of years like “fire” in human evolution. Its ability to mimic human brain has led to identifying patterns and insights which were historically impossible or took a long time to manifest. e.g. while matching an image it tries to think like a human, using processes like Convolution Neural Networks, unlike some pre-defined algorithms which were tediously trained to function within some mathematical boundaries. AI is extending traditional Analytics to look beyond just numbers and statistics. It is revolutionizing the concept of “sensing” than “predicting”. These technologies are not new. While AI existed since 1950, the adoption has been high in recent times due to the availability of huge computing power, big data and reduced cost of implementation.

AI has already been adopted across several use cases like:

• Identifying Frauds with better accuracies
• Cross Selling and Up Selling using Chatbots/Virtual Assistance
• AI-assisted portfolio management
• IoT to better manage marketing across multi-customer touch points
• Process automation like Contract Optimization

But are these actions sufficient for survival?

Unfortunately, history has been etched with battles between unconventional domains. Instances like the downfall of Kodak when they delayed the adoption of digital cameras or Airlines which has been impacted hugely by “video conferencing” technologies, or Amazon kindle impacting publication houses. Innovation is essential and at a faster pace. The marketplace has seen the entry of unconventional players like:

• Reliance Jio: They already have the huge customer base over 120 M and this customer reach may increase exponential possessing threat to conventional bankers
• PayTM: It has expanded from a wallet to marketplace with a customer base of 200 M. With humongous gamut of offers in their kitty and a favorable customer perception, they have already started putting a dent in the online transactions & payment market
• In global markets: Jawbone and Amex have developed fitness + payment tracker “UP4”, thus helping payment channels as a natural extension of human everyday life or Westpac coming up with Geo-location specific marketing
• P2P lenders and their alarming growth rate of 300% in the last couple of years

Banking needs to leapfrog from the traditional way of doing things to new ways of thinking.

Can Banking be done differently to “thrive than just survive”?

With AI getting more “Context-Aware” and frameworks like Ubiquitous Computing gaining prominence, “Cyber-Physical” systems will become a reality or has become one as discussed in the “UP4” examples. Banking cannot just survive on innovation/automation alone, it needs to “Transform”. Bankers need fiction writers, the futurist who can dream of future. All we can say is there needs to be a “Trans-Morphosis”, from natural genetic change to a non-predefined transition.

If we re-visualize the opportunities through the prism of “Trans-Morphosis” few of those things can be done differently:

• Stopping a fraud before it happens- Like Manufacturing can we develop on the lines of “Preventive Maintenance” to sense trends before the “Boiler” fails
• Incentivizing customers for having a high credit score – Like Insurance sector, where better drivers are awarded “No Claim” bonuses
• Transforming Virtual Assistants to be Virtual Mentors – Help customers, not just with the best offers but suggestions to fulfill their dreams e.g. help to maximize savings for the down payment of a car by liquidating portion of existing saving portfolios like SIP, Mutual funds etc. seamlessly

These are just a few possibilities. Just think of additional opportunities like

• Shared Risk Platform across multi-partners or other banks – like blockchain, where risks are shared among multiple stakeholders. A recent defaulter with good credit history applies for a loan. His current requirement can be funded by multiple banking partners each sharing a portion of the risk. The risk value, loan amount and lending time/rates can be evaluated through AI to mitigate risk and help customers with better experience while ensuring he is still the part of the banking system
• Understand customer needs in real time based on what preferences influenced by one’s social setting e.g. what others who can influence him/her are spending on. Our decisions may be correlated by some facts but we humans may not behave rationally. So rather than predicting, since the possibilities through AI

What this decade is seeing is data-based decision making moving from being a decision aid to being the decision engine to almost being the decision maker.

To conclude “Data is the new nuclear fuel and AI is the reactor”. If controlled and curated we can fulfill numerous next-gen possibilities.